home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / java.g < prev    next >
Text File  |  1999-05-14  |  122KB  |  4,964 lines
  1. %options scopes,act,an=javaact.cpp,hn=javaact.h,em,tab,gp=c++,
  2. %options fp=java,escape=$,prefix=TK_,em,defer,output-size=125
  3. %options hblockb=\:,hblocke=:\
  4. %options nogoto-default
  5. %options single-productions
  6. %options la=2,names=max
  7.  
  8. -- This software is subject to the terms of the IBM Jikes Compiler
  9. -- License Agreement available at the following URL:
  10. -- http://www.ibm.com/research/jikes.
  11. -- Copyright (C) 1996, 1999, International Business Machines Corporation
  12. -- and others.  All Rights Reserved.
  13. -- You must accept the terms of that agreement to use this software.
  14.  
  15. ------------------------------------------------------------------------
  16. --
  17. --                               J A V A
  18. --
  19. -- This Java grammar is almost identical to the grammar defined in
  20. -- chapter 19 of the Java Language Specification manual together with
  21. -- the additional rules found in the 1.1 document. It is written here
  22. -- in JIKES PG format with semantic actions following each rule. In
  23. -- specifying the rules we enclosed all terminal symbols in single
  24. -- quotes so that they can be quickly distinguished from
  25. -- non-terminals. Optional symbols are suffixed with a question mark (?)
  26. -- and the rules expanding such definitions can be found at the end.
  27. --
  28. -- This grammar is totally faithful to the original rules except that
  29. -- some syntactic markers: PackageHeaderMarker, MethodHeaderMarker and
  30. -- BodyMarker, were added to allow the parser to skip certain irrelevant
  31. -- syntactic components when they are not needed.
  32. --
  33. -- The file javaact.h produced by JIKESPG from this file (java.g) contains a
  34. -- very readable definition of the grammar rules together with their
  35. -- associated semantic actions. That file is marked with appropriate
  36. -- location directives (automatically generated) which instructs the C++
  37. -- compiler to issue error messages in terms of this file (java.g).
  38. -- Therefore, though the user is encouraged to read javaact.h, no
  39. -- change should ever be made to that file. Instead, changes should
  40. -- always be made in this file and javaact.h should be regenerated
  41. -- using JIKESPG. 
  42. --
  43. ------------------------------------------------------------------------
  44.  
  45. $Define
  46.  
  47. --
  48. -- This macro generates a header for an action function consisting
  49. -- of the rule in question (commented) and a location directive.
  50. --
  51. $location
  52. /.
  53.  
  54. // 
  55. // Rule $rule_number:  $rule_text
  56. //
  57. #line $next_line "$input_file"./
  58.  
  59. --
  60. -- This macro is used to initialize the rule_action array
  61. -- to an unnamed function. A name is generated using the
  62. -- number of the rule in question.
  63. --
  64. $action
  65. /.
  66. #ifndef HEADERS
  67.     rule_action[$rule_number] = &Parser::Act$rule_number;
  68. #else
  69.     void Act$rule_number(void);
  70. #endif
  71. ./
  72.  
  73. --
  74. -- These macros are used to initialize the rule_action array
  75. -- to a specific named function.
  76. --
  77. $MakeArrayType
  78. /.
  79. #ifndef HEADERS
  80.     rule_action[$rule_number] = &Parser::MakeArrayType;
  81. #endif
  82. ./
  83.  
  84. $MakeSimpleName
  85. /.
  86. #ifndef HEADERS
  87.     rule_action[$rule_number] = &Parser::MakeSimpleName;
  88. #endif
  89. ./
  90.  
  91. $MakeFieldAccess
  92. /.
  93. #ifndef HEADERS
  94.     rule_action[$rule_number] = &Parser::MakeFieldAccess;
  95. #endif
  96. ./
  97.  
  98. $MakeQualifiedSuper
  99. /.
  100. #ifndef HEADERS
  101.     rule_action[$rule_number] = &Parser::MakeQualifiedSuper;
  102. #endif
  103. ./
  104.  
  105. $MakeQualifiedNew
  106. /.
  107. #ifndef HEADERS
  108.     rule_action[$rule_number] = &Parser::MakeQualifiedNew;
  109. #endif
  110. ./
  111.  
  112. $SetSym1ToSym2
  113. /.
  114. #ifndef HEADERS
  115.     rule_action[$rule_number] = &Parser::SetSym1ToSym2;
  116. #endif
  117. ./
  118.  
  119. $MakeEmptyStatement
  120. /.
  121. #ifndef HEADERS
  122.     rule_action[$rule_number] = &Parser::MakeEmptyStatement;
  123. #endif
  124. ./
  125.  
  126. $MakeLabeledStatement
  127. /.
  128. #ifndef HEADERS
  129.     rule_action[$rule_number] = &Parser::MakeLabeledStatement;
  130. #endif
  131. ./
  132.  
  133. $MakeExpressionStatement
  134. /.
  135. #ifndef HEADERS
  136.     rule_action[$rule_number] = &Parser::MakeExpressionStatement;
  137. #endif
  138. ./
  139.  
  140. $MakeIfThenElseStatement
  141. /.
  142. #ifndef HEADERS
  143.     rule_action[$rule_number] = &Parser::MakeIfThenElseStatement;
  144. #endif
  145. ./
  146.  
  147. $MakeWhileStatement
  148. /.
  149. #ifndef HEADERS
  150.     rule_action[$rule_number] = &Parser::MakeWhileStatement;
  151. #endif
  152. ./
  153.  
  154. $MakeForStatement
  155. /.
  156. #ifndef HEADERS
  157.     rule_action[$rule_number] = &Parser::MakeForStatement;
  158. #endif
  159. ./
  160.  
  161. $MakeArrayCreationExpression
  162. /.
  163. #ifndef HEADERS
  164.     rule_action[$rule_number] = &Parser::MakeArrayCreationExpression;
  165. #endif
  166. ./
  167.  
  168. $MakeSuperFieldAccess
  169. /.
  170. #ifndef HEADERS
  171.     rule_action[$rule_number] = &Parser::MakeSuperFieldAccess;
  172. #endif
  173. ./
  174.  
  175. $MakeSuperDoubleFieldAccess
  176. /.
  177. #ifndef HEADERS
  178.     rule_action[$rule_number] = &Parser::MakeSuperDoubleFieldAccess;
  179. #endif
  180. ./
  181.  
  182. $MakeArrayAccess
  183. /.
  184. #ifndef HEADERS
  185.     rule_action[$rule_number] = &Parser::MakeArrayAccess;
  186. #endif
  187. ./
  188.  
  189. $MakeCastExpression
  190. /.
  191. #ifndef HEADERS
  192.     rule_action[$rule_number] = &Parser::MakeCastExpression;
  193. #endif
  194. ./
  195.  
  196. -- 
  197. -- This macro is used to initialize the rule_action array
  198. -- to the NullAction function.
  199. --
  200. $NullAction
  201. /.
  202. #ifndef HEADERS
  203.     rule_action[$rule_number] = &Parser::NullAction;
  204. #endif
  205. ./
  206.  
  207. -- 
  208. -- This macro is used to initialize the rule_action array
  209. -- to the NoAction function.
  210. --
  211. $NoAction
  212. /.
  213. #ifndef HEADERS
  214.     rule_action[$rule_number] = &Parser::NoAction;
  215. #endif
  216. ./
  217.  
  218. -- 
  219. -- This macro generates a header for a named action function that is
  220. -- already defined and will be shared.
  221. --
  222. $shared_function
  223. /.
  224.  
  225. //
  226. // Rule $rule_number:  $rule_text./
  227.  
  228. -- 
  229. -- This macro generates a header for a rule that invokes the
  230. -- no_function routine.
  231. --
  232. $shared_NoAction
  233. /.
  234.  
  235. //
  236. // Rule $rule_number:  $rule_text
  237. //
  238. // void NoAction(void);
  239. //./
  240.  
  241. -- 
  242. -- This macro generates a header for a rule that invokes the
  243. -- null_function routine.
  244. --
  245. $shared_NullAction
  246. /.
  247.  
  248. //
  249. // Rule $rule_number:  $rule_text
  250. //
  251. // void NullAction(void);
  252. //./
  253.  
  254. $Terminals
  255.  
  256.     BodyMarker
  257.  
  258.     Identifier
  259.  
  260.     abstract boolean break byte case catch char class const
  261.     continue default do double else extends false final finally float
  262.     for goto if implements import instanceof int
  263.     interface long native new null package private
  264.     protected public return short static strictfp super switch
  265.     synchronized this throw throws transient true try void
  266.     volatile while
  267.  
  268.     IntegerLiteral
  269.     LongLiteral
  270.     FloatingPointLiteral
  271.     DoubleLiteral
  272.     CharacterLiteral
  273.     StringLiteral
  274.  
  275.     PLUS_PLUS
  276.     MINUS_MINUS
  277.     EQUAL_EQUAL
  278.     LESS_EQUAL
  279.     GREATER_EQUAL
  280.     NOT_EQUAL
  281.     LEFT_SHIFT
  282.     RIGHT_SHIFT
  283.     UNSIGNED_RIGHT_SHIFT
  284.     PLUS_EQUAL
  285.     MINUS_EQUAL
  286.     MULTIPLY_EQUAL
  287.     DIVIDE_EQUAL
  288.     AND_EQUAL
  289.     OR_EQUAL
  290.     XOR_EQUAL
  291.     REMAINDER_EQUAL
  292.     LEFT_SHIFT_EQUAL
  293.     RIGHT_SHIFT_EQUAL
  294.     UNSIGNED_RIGHT_SHIFT_EQUAL
  295.     OR_OR
  296.     AND_AND
  297.     PLUS
  298.     MINUS
  299.     NOT
  300.     REMAINDER
  301.     XOR
  302.     AND
  303.     MULTIPLY
  304.     OR
  305.     TWIDDLE
  306.     DIVIDE
  307.     GREATER
  308.     LESS
  309.     LPAREN
  310.     RPAREN
  311.     LBRACE
  312.     RBRACE
  313.     LBRACKET
  314.     RBRACKET
  315.     SEMICOLON
  316.     QUESTION
  317.     COLON
  318.     COMMA
  319.     DOT
  320.     EQUAL
  321.  
  322.     ERROR
  323.     EOF
  324.     EOL
  325.  
  326. $Alias
  327.  
  328.     '++'   ::= PLUS_PLUS
  329.     '--'   ::= MINUS_MINUS
  330.     '=='   ::= EQUAL_EQUAL
  331.     '<='   ::= LESS_EQUAL
  332.     '>='   ::= GREATER_EQUAL
  333.     '!='   ::= NOT_EQUAL
  334.     '<<'   ::= LEFT_SHIFT
  335.     '>>'   ::= RIGHT_SHIFT
  336.     '>>>'  ::= UNSIGNED_RIGHT_SHIFT
  337.     '+='   ::= PLUS_EQUAL
  338.     '-='   ::= MINUS_EQUAL
  339.     '*='   ::= MULTIPLY_EQUAL
  340.     '/='   ::= DIVIDE_EQUAL
  341.     '&='   ::= AND_EQUAL
  342.     '|='   ::= OR_EQUAL
  343.     '^='   ::= XOR_EQUAL
  344.     '%='   ::= REMAINDER_EQUAL
  345.     '<<='  ::= LEFT_SHIFT_EQUAL
  346.     '>>='  ::= RIGHT_SHIFT_EQUAL
  347.     '>>>=' ::= UNSIGNED_RIGHT_SHIFT_EQUAL
  348.     '||'   ::= OR_OR
  349.     '&&'   ::= AND_AND
  350.  
  351.     '+'    ::= PLUS
  352.     '-'    ::= MINUS
  353.     '!'    ::= NOT
  354.     '%'    ::= REMAINDER
  355.     '^'    ::= XOR
  356.     '&'    ::= AND
  357.     '*'    ::= MULTIPLY
  358.     '|'    ::= OR
  359.     '~'    ::= TWIDDLE
  360.     '/'    ::= DIVIDE
  361.     '>'    ::= GREATER
  362.     '<'    ::= LESS
  363.     '('    ::= LPAREN
  364.     ')'    ::= RPAREN
  365.     '{'    ::= LBRACE
  366.     '}'    ::= RBRACE
  367.     '['    ::= LBRACKET
  368.     ']'    ::= RBRACKET
  369.     ';'    ::= SEMICOLON
  370.     '?'    ::= QUESTION
  371.     ':'    ::= COLON
  372.     ','    ::= COMMA
  373.     '.'    ::= DOT
  374.     '='    ::= EQUAL
  375.  
  376.     $EOF   ::= EOF
  377.     $ERROR ::= ERROR
  378.  
  379.     $EOL   ::= ;
  380.  
  381. $Start
  382.  
  383.     Goal
  384.  
  385. $Rules
  386.  
  387. \:
  388. //
  389. // This software is subject to the terms of the IBM Jikes Compiler Open
  390. // Source License Agreement available at the following URL:
  391. // http://www.ibm.com/research/jikes.
  392. // Copyright (C) 1996, 1998, International Business Machines Corporation
  393. // and others.  All Rights Reserved.
  394. // You must accept the terms of that agreement to use this software.
  395. //
  396.  
  397. #ifndef HEADERS
  398. void Parser::InitRuleAction()
  399. {
  400.     rule_action[0] = &Parser::BadAction;
  401. #else
  402.     void BadAction(void);
  403.     void NoAction(void);
  404.     void NullAction(void);
  405.     void MakeArrayType(void);
  406.     void MakeSimpleName(void);
  407.     void MakeFieldAccess(void);
  408.     void MakeQualifiedSuper(void);
  409.     void MakeQualifiedNew(void);
  410.     void SetSym1ToSym2(void);
  411.     void MakeEmptyStatement(void);
  412.     void MakeLabeledStatement(void);
  413.     void MakeExpressionStatement(void);
  414.     void MakeIfThenElseStatement(void);
  415.     void MakeWhileStatement(void);
  416.     void MakeForStatement(void);
  417.     void MakeArrayCreationExpression(void);
  418.     void MakeSuperFieldAccess(void);
  419.     void MakeSuperDoubleFieldAccess(void);
  420.     void MakeArrayAccess(void);
  421.     void MakeCastExpression(void);
  422. #endif
  423.  
  424. :\
  425.  
  426. /.#line $next_line "$input_file"
  427. //
  428. // This software is subject to the terms of the IBM Jikes Compiler Open
  429. // Source License Agreement available at the following URL:
  430. // http://www.ibm.com/research/jikes.
  431. // Copyright (C) 1996, 1998, International Business Machines Corporation
  432. // and others.  All Rights Reserved.
  433. // You must accept the terms of that agreement to use this software.
  434. //
  435.  
  436. #include "config.h"
  437. #include "parser.h"
  438. #include "ast.h"
  439.  
  440. #undef HEADERS
  441. #include "javaact.h"
  442.  
  443. //****************************************************************************//
  444. //****************************************************************************//
  445. //*                                                                          *//
  446. //* Below, we show each rule of the Java grammar together with the semantic  *//
  447. //* action that is invoked when the parser performs a reduction by that rule.*//
  448. //*                                                                          *//
  449. //****************************************************************************//
  450. //****************************************************************************//
  451.  
  452. ./
  453.  
  454. --18.2 Productions from 2.3: The syntactic Grammar
  455.  
  456. Goal -> CompilationUnit
  457. \:$NoAction:\
  458. /.$location
  459. //
  460. // Given a rule of the form A ::= x1 x2 ... xn        n >= 1
  461. //
  462. // Do nothing - Whatever Ast was produced for x1 is inherited by A.
  463. //
  464. void Parser::BadAction(void) { assert(0); }
  465. void Parser::NoAction(void) {}
  466. ./
  467.  
  468. Goal ::= BodyMarker ConstructorBody
  469. \:$action:\
  470. /.$location
  471. //
  472. // This rule was added to allow the parser to recognize the body of a
  473. // funtion (constructor or method, as the definition of the body of a
  474. // method is subsumed by the definition of the body of a constructor)
  475. // out of context. Note that the artificial terminal BodyMarker is
  476. // added here to prevent an ordinary parse from accepting a body as
  477. // a valid input - i.e., to recognize a body out-of-context, the
  478. // BodyMarker terminal must be inserted in front of the input stream
  479. // containing the body in question.
  480. //
  481. void Parser::Act$rule_number(void)
  482. {
  483.     Sym(1) = Sym(2);
  484. }
  485. ./
  486.  
  487.  
  488. --18.3 Productions from 3: Lexical Structure
  489. --
  490. -- Expand the definition IntegerLiteral and BooleanLiteral
  491. --
  492.  
  493. Literal ::= IntegerLiteral
  494. \:$action:\
  495. /.$location
  496. void Parser::Act$rule_number(void)
  497. {
  498.     Sym(1) = ast_pool -> NewIntegerLiteral(Token(1));
  499. }
  500. ./
  501.  
  502. Literal ::= LongLiteral
  503. \:$action:\
  504. /.$location
  505. void Parser::Act$rule_number(void)
  506. {
  507.     Sym(1) = ast_pool -> NewLongLiteral(Token(1));
  508. }
  509. ./
  510.  
  511. Literal ::= FloatingPointLiteral
  512. \:$action:\
  513. /.$location
  514. void Parser::Act$rule_number(void)
  515. {
  516.     Sym(1) = ast_pool -> NewFloatingPointLiteral(Token(1));
  517. }
  518. ./
  519.  
  520. Literal ::= DoubleLiteral
  521. \:$action:\
  522. /.$location
  523. void Parser::Act$rule_number(void)
  524. {
  525.     Sym(1) = ast_pool -> NewDoubleLiteral(Token(1));
  526. }
  527. ./
  528.  
  529. Literal -> BooleanLiteral
  530. \:$NoAction:\
  531. /.$shared_NoAction./
  532.  
  533. Literal ::= CharacterLiteral
  534. \:$action:\
  535. /.$location
  536. void Parser::Act$rule_number(void)
  537. {
  538.     Sym(1) = ast_pool -> NewCharacterLiteral(Token(1));
  539. }
  540. ./
  541.  
  542. Literal ::= StringLiteral
  543. \:$action:\
  544. /.$location
  545. void Parser::Act$rule_number(void)
  546. {
  547.     Sym(1) = ast_pool -> NewStringLiteral(Token(1));
  548. }
  549. ./
  550.  
  551. Literal ::= null
  552. \:$action:\
  553. /.$location
  554. void Parser::Act$rule_number(void)
  555. {
  556.     Sym(1) = ast_pool -> NewNullLiteral(Token(1));
  557. }
  558. ./
  559.  
  560. BooleanLiteral ::= true
  561. \:$action:\
  562. /.$location
  563. void Parser::Act$rule_number(void)
  564. {
  565.     Sym(1) = ast_pool -> NewTrueLiteral(Token(1));
  566. }
  567. ./
  568.  
  569. BooleanLiteral ::= false
  570. \:$action:\
  571. /.$location
  572. void Parser::Act$rule_number(void)
  573. {
  574.     Sym(1) = ast_pool -> NewFalseLiteral(Token(1));
  575. }
  576. ./
  577.  
  578. --18.4 Productions from 4: Types, Values and Variables
  579.  
  580. Type -> PrimitiveType
  581. \:$NoAction:\
  582. /.$shared_NoAction./
  583.  
  584. Type -> ReferenceType
  585. \:$NoAction:\
  586. /.$shared_NoAction./
  587.  
  588. PrimitiveType -> NumericType
  589. \:$NoAction:\
  590. /.$shared_NoAction./
  591.  
  592. PrimitiveType ::= 'boolean'
  593. \:$action:\
  594. /.$location
  595. void Parser::Act$rule_number(void)
  596. {
  597.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::BOOLEAN, Token(1));
  598. }
  599. ./
  600.  
  601. NumericType -> IntegralType
  602. \:$NoAction:\
  603. /.$shared_NoAction./
  604.  
  605. NumericType -> FloatingPointType
  606. \:$NoAction:\
  607. /.$shared_NoAction./
  608.  
  609. IntegralType ::= 'byte'
  610. \:$action:\
  611. /.$location
  612. void Parser::Act$rule_number(void)
  613. {
  614.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::BYTE, Token(1));
  615. }
  616. ./
  617.  
  618. IntegralType ::= 'short'
  619. \:$action:\
  620. /.$location
  621. void Parser::Act$rule_number(void)
  622. {
  623.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::SHORT, Token(1));
  624. }
  625. ./
  626.  
  627. IntegralType ::= 'int'
  628. \:$action:\
  629. /.$location
  630. void Parser::Act$rule_number(void)
  631. {
  632.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::INT, Token(1));
  633. }
  634. ./
  635.  
  636. IntegralType ::= 'long'
  637. \:$action:\
  638. /.$location
  639. void Parser::Act$rule_number(void)
  640. {
  641.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::LONG, Token(1));
  642. }
  643. ./
  644.  
  645. IntegralType ::= 'char'
  646. \:$action:\
  647. /.$location
  648. void Parser::Act$rule_number(void)
  649. {
  650.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::CHAR, Token(1));
  651. }
  652. ./
  653.  
  654. FloatingPointType ::= 'float'
  655. \:$action:\
  656. /.$location
  657. void Parser::Act$rule_number(void)
  658. {
  659.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::FLOAT, Token(1));
  660. }
  661. ./
  662.  
  663. FloatingPointType ::= 'double'
  664. \:$action:\
  665. /.$location
  666. void Parser::Act$rule_number(void)
  667. {
  668.     Sym(1) = ast_pool -> NewPrimitiveType(Ast::DOUBLE, Token(1));
  669. }
  670. ./
  671.  
  672. ReferenceType -> ClassOrInterfaceType
  673. \:$NoAction:\
  674. /.$shared_NoAction./
  675.  
  676. ReferenceType -> ArrayType
  677. \:$NoAction:\
  678. /.$shared_NoAction./
  679.  
  680. ClassOrInterfaceType -> Name
  681. \:$NoAction:\
  682. /.$shared_NoAction./
  683.  
  684. --
  685. -- These rules have been rewritten to avoid some conflicts introduced
  686. -- by adding the 1.1 features
  687. --
  688. -- ArrayType ::= PrimitiveType '[' ']'
  689. -- ArrayType ::= Name '[' ']'
  690. -- ArrayType ::= ArrayType '[' ']'
  691. --
  692. ArrayType ::= PrimitiveType Dims
  693. \:$MakeArrayType:\
  694. /.$location
  695. void Parser::MakeArrayType(void)
  696. {
  697.     AstArrayType *p = ast_pool -> NewArrayType();
  698.     p -> type     = Sym(1);
  699.     //
  700.     // The list of modifiers is guaranteed not empty
  701.     //
  702.     {   
  703.         AstListNode *tail = (AstListNode *) Sym(2);
  704.         p -> AllocateBrackets(tail -> index + 1);
  705.         AstListNode *root = tail;
  706.         do
  707.         {
  708.             root = root -> next;
  709.             p -> AddBrackets((AstBrackets *) root -> element);
  710.         } while(root != tail);
  711.         FreeCircularList(tail);
  712.     }
  713.     Sym(1) = p;
  714. }
  715. ./
  716.  
  717. ArrayType ::= Name Dims
  718. \:$MakeArrayType:\
  719. /.$shared_function 
  720. //
  721. // void MakeArrayType(void);
  722. //./
  723.  
  724. ClassType -> ClassOrInterfaceType
  725. \:$NoAction:\
  726. /.$shared_NoAction./
  727.  
  728. InterfaceType -> ClassOrInterfaceType
  729. \:$NoAction:\
  730. /.$shared_NoAction./
  731.  
  732. --18.5 Productions from 6: Names
  733.  
  734. Name -> SimpleName
  735. \:$NoAction:\
  736. /.$shared_NoAction./
  737.  
  738. Name -> QualifiedName
  739. \:$NoAction:\
  740. /.$shared_NoAction./
  741.  
  742. SimpleName ::= 'Identifier'
  743. \:$MakeSimpleName:\
  744. /.$location
  745. void Parser::MakeSimpleName(void)
  746. {
  747.     Sym(1) = ast_pool -> NewSimpleName(Token(1));
  748. }
  749. ./
  750.  
  751. QualifiedName ::= Name '.' 'Identifier'
  752. \:$MakeFieldAccess:\
  753. /.$location
  754. void Parser::MakeFieldAccess(void)
  755. { 
  756.     AstFieldAccess *p = ast_pool -> NewFieldAccess();
  757.     p -> base = (AstExpression *) Sym(1);
  758.     p -> dot_token = Token(2);
  759.     p -> identifier_token = Token(3);
  760.     Sym(1) = p;
  761. }
  762. ./
  763.  
  764. --18.6 Productions from 7: Packages
  765.  
  766. CompilationUnit ::= PackageDeclarationopt ImportDeclarationsopt TypeDeclarationsopt
  767. \:$action:\
  768. /.$location
  769. void Parser::Act$rule_number(void)
  770. {
  771.     AstCompilationUnit *p = ast_pool -> NewCompilationUnit();
  772.     p -> package_declaration_opt = (AstPackageDeclaration *) Sym(1);
  773.     if (Sym(2) != NULL)
  774.     {
  775.         AstListNode *tail = (AstListNode *) Sym(2);
  776.         p -> AllocateImportDeclarations(tail -> index + 1);
  777.         AstListNode *root = tail;
  778.         do
  779.         {
  780.             root = root -> next;
  781.             p -> AddImportDeclaration((AstImportDeclaration *) root -> element);
  782.         } while(root != tail);
  783.         FreeCircularList(tail);
  784.     }
  785.     if (Sym(3) != NULL)
  786.     {
  787.         AstListNode *tail = (AstListNode *) Sym(3);
  788.         p -> AllocateTypeDeclarations(tail -> index + 1);
  789.         AstListNode *root = tail;
  790.         do
  791.         {
  792.             root = root -> next;
  793.             p -> AddTypeDeclaration(root -> element);
  794.         } while(root != tail);
  795.         FreeCircularList(tail);
  796.     }
  797.     Sym(1) = p;
  798. }
  799. ./
  800.  
  801. ImportDeclarations ::= ImportDeclaration
  802. \:$action:\
  803. /.$location
  804. //
  805. // Note that the list is circular so as to preserve the order of the elements
  806. //
  807. void Parser::Act$rule_number(void)
  808. {
  809.     AstListNode *p = AllocateListNode();
  810.     p -> next = p;
  811.     p -> element = Sym(1);
  812.     p -> index = 0;
  813.  
  814.     Sym(1) = p;
  815. }
  816. ./
  817.  
  818. ImportDeclarations ::= ImportDeclarations ImportDeclaration
  819. \:$action:\
  820. /.$location
  821. //
  822. // Note that the list is circular so as to preserve the order of the elements
  823. //
  824. void Parser::Act$rule_number(void)
  825. {
  826.     AstListNode *tail = (AstListNode *) Sym(1);
  827.  
  828.     AstListNode *p = AllocateListNode();
  829.     p -> element = Sym(2);
  830.     p -> index = tail -> index + 1;
  831.  
  832.     p -> next = tail -> next;
  833.     tail -> next = p;
  834.  
  835.     Sym(1) = p;
  836. }
  837. ./
  838.  
  839. TypeDeclarations ::= TypeDeclaration
  840. \:$action:\
  841. /.$location
  842. //
  843. // Note that the list is circular so as to preserve the order of the elements
  844. //
  845. void Parser::Act$rule_number(void)
  846. {
  847.     AstListNode *p = AllocateListNode();
  848.     p -> next = p;
  849.     p -> element = Sym(1);
  850.     p -> index = 0;
  851.  
  852.     Sym(1) = p;
  853. }
  854. ./
  855.  
  856. TypeDeclarations ::= TypeDeclarations TypeDeclaration
  857. \:$action:\
  858. /.$location
  859. //
  860. // Note that the list is circular so as to preserve the order of the elements
  861. //
  862. void Parser::Act$rule_number(void)
  863. {
  864.     AstListNode *tail = (AstListNode *) Sym(1);
  865.  
  866.     AstListNode *p = AllocateListNode();
  867.     p -> element = Sym(2);
  868.     p -> index = tail -> index + 1;
  869.  
  870.     p -> next = tail -> next;
  871.     tail -> next = p;
  872.  
  873.     Sym(1) = p;
  874. }
  875. ./
  876.  
  877. PackageDeclaration ::= 'package' Name PackageHeaderMarker ';'
  878. \:$action:\
  879. /.$location
  880. void Parser::Act$rule_number(void)
  881. {
  882.     AstPackageDeclaration *p = ast_pool -> NewPackageDeclaration();
  883.     p -> package_token   = Token(1);
  884.     p -> name            = (AstExpression *) Sym(2);
  885.     p -> semicolon_token = Token(3);
  886.     Sym(1) = p;
  887. }
  888. ./
  889.  
  890. ImportDeclaration -> SingleTypeImportDeclaration
  891. \:$NoAction:\
  892. /.$shared_NoAction./
  893.  
  894. ImportDeclaration -> TypeImportOnDemandDeclaration
  895. \:$NoAction:\
  896. /.$shared_NoAction./
  897.  
  898. SingleTypeImportDeclaration ::= 'import' Name ';'
  899. \:$action:\
  900. /.$location
  901. void Parser::Act$rule_number(void)
  902. {
  903.     AstImportDeclaration *p = ast_pool -> NewImportDeclaration();
  904.     p -> import_token    = Token(1);
  905.     p -> name            = (AstExpression *) Sym(2);
  906.     p -> star_token_opt  = 0;
  907.     p -> semicolon_token = Token(3);
  908.     Sym(1) = p;
  909. }
  910. ./
  911.  
  912. TypeImportOnDemandDeclaration ::= 'import' Name '.' '*' ';'
  913. \:$action:\
  914. /.$location
  915. void Parser::Act$rule_number(void)
  916. {
  917.     AstImportDeclaration *p = ast_pool -> NewImportDeclaration();
  918.     p -> import_token         = Token(1);
  919.     p -> name                 = (AstExpression *) Sym(2);
  920.     p -> star_token_opt       = Token(4);
  921.     p -> semicolon_token      = Token(5);
  922.     Sym(1) = p;
  923. }
  924. ./
  925.  
  926. TypeDeclaration -> ClassDeclaration
  927. \:$NoAction:\
  928. /.$shared_NoAction./
  929.  
  930. TypeDeclaration -> InterfaceDeclaration
  931. \:$NoAction:\
  932. /.$shared_NoAction./
  933.  
  934. TypeDeclaration ::= ';'
  935. \:$action:\
  936. /.$location
  937. void Parser::Act$rule_number(void)
  938. {
  939.     Sym(1) = ast_pool -> NewEmptyDeclaration(Token(1));
  940. }
  941. ./
  942.  
  943. --18.7 Only in the LALR(1) Grammar
  944.  
  945. Modifiers ::= Modifier
  946. \:$action:\
  947. /.$location
  948. //
  949. // Note that the list is circular so as to preserve the order of the elements
  950. //
  951. void Parser::Act$rule_number(void)
  952. {
  953.     AstListNode *p = AllocateListNode();
  954.     p -> next = p;
  955.     p -> element = Sym(1);
  956.     p -> index = 0;
  957.  
  958.     Sym(1) = p;
  959. }
  960. ./
  961.  
  962. Modifiers ::= Modifiers Modifier
  963. \:$action:\
  964. /.$location
  965. //
  966. // Note that the list is circular so as to preserve the order of the elements
  967. //
  968. void Parser::Act$rule_number(void)
  969. {
  970.     AstListNode *tail = (AstListNode *) Sym(1);
  971.  
  972.     AstListNode *p = AllocateListNode();
  973.     p -> element = Sym(2);
  974.     p -> index = tail -> index + 1;
  975.  
  976.     p -> next = tail -> next;
  977.     tail -> next = p;
  978.  
  979.     Sym(1) = p;
  980. }
  981. ./
  982.  
  983. Modifier ::= 'public'
  984. \:$action:\
  985. /.$location
  986. void Parser::Act$rule_number(void)
  987. {
  988.     Sym(1) = ast_pool -> NewModifier(Ast::PUBLIC, Token(1));
  989. }
  990. ./
  991.  
  992. Modifier ::= 'protected'
  993. \:$action:\
  994. /.$location
  995. void Parser::Act$rule_number(void)
  996. {
  997.     Sym(1) = ast_pool -> NewModifier(Ast::PROTECTED, Token(1));
  998. }
  999. ./
  1000.  
  1001. Modifier ::= 'private'
  1002. \:$action:\
  1003. /.$location
  1004. void Parser::Act$rule_number(void)
  1005. {
  1006.     Sym(1) = ast_pool -> NewModifier(Ast::PRIVATE, Token(1));
  1007. }
  1008. ./
  1009.  
  1010. Modifier ::= 'static'
  1011. \:$action:\
  1012. /.$location
  1013. void Parser::Act$rule_number(void)
  1014. {
  1015.     Sym(1) = ast_pool -> NewModifier(Ast::STATIC, Token(1));
  1016. }
  1017. ./
  1018.  
  1019. Modifier ::= 'abstract'
  1020. \:$action:\
  1021. /.$location
  1022. void Parser::Act$rule_number(void)
  1023. {
  1024.     Sym(1) = ast_pool -> NewModifier(Ast::ABSTRACT, Token(1));
  1025. }
  1026. ./
  1027.  
  1028. Modifier ::= 'final'
  1029. \:$action:\
  1030. /.$location
  1031. void Parser::Act$rule_number(void)
  1032. {
  1033.     Sym(1) = ast_pool -> NewModifier(Ast::FINAL, Token(1));
  1034. }
  1035. ./
  1036.  
  1037. Modifier ::= 'native'
  1038. \:$action:\
  1039. /.$location
  1040. void Parser::Act$rule_number(void)
  1041. {
  1042.     Sym(1) = ast_pool -> NewModifier(Ast::NATIVE, Token(1));
  1043. }
  1044. ./
  1045.  
  1046. Modifier ::= 'strictfp'
  1047. \:$action:\
  1048. /.$location
  1049. void Parser::Act$rule_number(void)
  1050. {
  1051.     Sym(1) = ast_pool -> NewModifier(Ast::STRICTFP, Token(1));
  1052. }
  1053. ./
  1054.  
  1055. Modifier ::= 'synchronized'
  1056. \:$action:\
  1057. /.$location
  1058. void Parser::Act$rule_number(void)
  1059. {
  1060.     Sym(1) = ast_pool -> NewModifier(Ast::SYNCHRONIZED, Token(1));
  1061. }
  1062. ./
  1063.  
  1064. Modifier ::= 'transient'
  1065. \:$action:\
  1066. /.$location
  1067. void Parser::Act$rule_number(void)
  1068. {
  1069.     Sym(1) = ast_pool -> NewModifier(Ast::TRANSIENT, Token(1));
  1070. }
  1071. ./
  1072.  
  1073. Modifier ::= 'volatile'
  1074. \:$action:\
  1075. /.$location
  1076. void Parser::Act$rule_number(void)
  1077. {
  1078.     Sym(1) = ast_pool -> NewModifier(Ast::VOLATILE, Token(1));
  1079. }
  1080. ./
  1081.  
  1082. --18.8 Productions from 8: Class Declarations
  1083. --ClassModifier ::=
  1084. --      'abstract'
  1085. --    | 'final'
  1086. --    | 'public'
  1087. --18.8.1 Productions from 8.1: Class Declarations
  1088.  
  1089. ClassDeclaration ::= Modifiersopt 'class' 'Identifier' Superopt Interfacesopt ClassBody
  1090. \:$action:\
  1091. /.$location
  1092. void Parser::Act$rule_number(void)
  1093. {
  1094.     AstClassDeclaration *p = ast_pool -> NewClassDeclaration();
  1095.     if (Sym(1) != NULL)
  1096.     {
  1097.         AstListNode *tail = (AstListNode *) Sym(1);
  1098.         p -> AllocateClassModifiers(tail -> index + 1);
  1099.         AstListNode *root = tail;
  1100.         do
  1101.         {
  1102.             root = root -> next;
  1103.             p -> AddClassModifier((AstModifier *) root -> element);
  1104.         } while(root != tail);
  1105.         FreeCircularList(tail);
  1106.     }
  1107.     p -> class_token          = Token(2);
  1108.     p -> identifier_token     = Token(3);
  1109.     p -> super_opt            = (AstExpression *) Sym(4);
  1110.     if (Sym(5) != NULL)
  1111.     {
  1112.         AstListNode *tail = (AstListNode *) Sym(5);
  1113.         p -> AllocateInterfaces(tail -> index + 1);
  1114.         AstListNode *root = tail;
  1115.         do
  1116.         {
  1117.             root = root -> next;
  1118.             p -> AddInterface((AstExpression *) root -> element);
  1119.         } while(root != tail);
  1120.         FreeCircularList(tail);
  1121.     }
  1122.     p -> class_body = (AstClassBody *) Sym(6);
  1123.     Sym(1) = p;
  1124. }
  1125. ./
  1126.  
  1127. Super ::= 'extends' ClassType
  1128. \:$SetSym1ToSym2:\
  1129. /.$location
  1130. void Parser::SetSym1ToSym2(void) { Sym(1) = Sym(2); }
  1131. ./
  1132.  
  1133. Interfaces ::= 'implements' InterfaceTypeList
  1134. \:$SetSym1ToSym2:\
  1135. /.$shared_function
  1136. //
  1137. // void SetSym1ToSym2(void);
  1138. //./
  1139.  
  1140. InterfaceTypeList ::= InterfaceType
  1141. \:$action:\
  1142. /.$location
  1143. //
  1144. // Note that the list is circular so as to preserve the order of the elements
  1145. //
  1146. void Parser::Act$rule_number(void)
  1147. {
  1148.     AstListNode *p = AllocateListNode();
  1149.     p -> next = p;
  1150.     p -> element = Sym(1);
  1151.     p -> index = 0;
  1152.  
  1153.     Sym(1) = p;
  1154. }
  1155. ./
  1156.  
  1157. InterfaceTypeList ::= InterfaceTypeList ',' InterfaceType
  1158. \:$action:\
  1159. /.$location
  1160. //
  1161. // Note that the list is circular so as to preserve the order of the elements
  1162. //
  1163. void Parser::Act$rule_number(void)
  1164. {
  1165.     AstListNode *tail = (AstListNode *) Sym(1);
  1166.  
  1167.     AstListNode *p = AllocateListNode();
  1168.     p -> element = Sym(3);
  1169.     p -> index = tail -> index + 1;
  1170.  
  1171.     p -> next = tail -> next;
  1172.     tail -> next = p;
  1173.  
  1174.     Sym(1) = p;
  1175. }
  1176. ./
  1177.  
  1178. ClassBody ::= '{' ClassBodyDeclarationsopt '}'
  1179. \:$action:\
  1180. /.$location
  1181. void Parser::Act$rule_number(void)
  1182. {
  1183.     AstClassBody *p = ast_pool -> NewClassBody();
  1184.     if (parse_header_only)
  1185.         p -> mark_unparsed();
  1186.  
  1187.     p -> left_brace_token = Token(1);
  1188.     if (Sym(2) != NULL)
  1189.     {
  1190.         int num_instance_variables = 0,
  1191.             num_class_variables = 0,
  1192.             num_methods = 0,
  1193.             num_constructors = 0,
  1194.             num_static_initializers = 0,
  1195.             num_inner_classes = 0,
  1196.             num_inner_interfaces = 0,
  1197.             num_blocks = 0,
  1198.             num_empty_declarations = 0;
  1199.  
  1200.         AstListNode *tail = (AstListNode *) Sym(2);
  1201.         p -> AllocateClassBodyDeclarations(tail -> index + 1);
  1202.         AstListNode *root = tail;
  1203.         do
  1204.         {
  1205.             root = root -> next;
  1206.             p -> AddClassBodyDeclaration(root -> element);
  1207.  
  1208.             AstFieldDeclaration *field_declaration = root -> element -> FieldDeclarationCast();
  1209.             if (field_declaration)
  1210.             {
  1211.                 for (int i = 0; i < field_declaration -> NumVariableModifiers(); i++)
  1212.                 {
  1213.                     if (field_declaration -> VariableModifier(i) -> kind == Ast::STATIC)
  1214.                     {
  1215.                         field_declaration -> MarkStatic();
  1216.                         break;
  1217.                     }
  1218.                 }
  1219.                 if (field_declaration -> StaticFieldCast())
  1220.                      num_class_variables++;
  1221.                 else num_instance_variables++;
  1222.             }
  1223.             else if (root -> element -> MethodDeclarationCast())
  1224.             {
  1225.                 num_methods++;
  1226.             }
  1227.             else if (root -> element -> ConstructorDeclarationCast())
  1228.             {
  1229.                 num_constructors++;
  1230.             }
  1231.             else if (root -> element -> StaticInitializerCast())
  1232.             {
  1233.                 num_static_initializers++;
  1234.             }
  1235.             else if (root -> element -> ClassDeclarationCast())
  1236.             {
  1237.                 num_inner_classes++;
  1238.             }
  1239.             else if (root -> element -> InterfaceDeclarationCast())
  1240.             {
  1241.                 num_inner_interfaces++;
  1242.             }
  1243.             else if (root -> element -> BlockCast())
  1244.             {
  1245.                 num_blocks++;
  1246.             }
  1247.             else num_empty_declarations++;
  1248.         } while(root != tail);
  1249.  
  1250.         p -> AllocateInstanceVariables(num_instance_variables);
  1251.         p -> AllocateClassVariables(num_class_variables);
  1252.         p -> AllocateMethods(num_methods);
  1253.         p -> AllocateConstructors(num_constructors);
  1254.         p -> AllocateStaticInitializers(num_static_initializers);
  1255.         p -> AllocateNestedClasses(num_inner_classes);
  1256.         p -> AllocateNestedInterfaces(num_inner_interfaces);
  1257.         p -> AllocateBlocks(num_blocks);
  1258.         p -> AllocateEmptyDeclarations(num_empty_declarations);
  1259.  
  1260.         root = tail;
  1261.         do
  1262.         {
  1263.             root = root -> next;
  1264.  
  1265.             AstFieldDeclaration *field_declaration;
  1266.             AstMethodDeclaration *method_declaration;
  1267.             AstConstructorDeclaration *constructor_declaration;
  1268.             AstStaticInitializer *static_initializer;
  1269.             AstClassDeclaration *class_declaration;
  1270.             AstInterfaceDeclaration *interface_declaration;
  1271.             AstBlock *block;
  1272.  
  1273.             if (field_declaration = root -> element -> FieldDeclarationCast())
  1274.             {
  1275.                 if (field_declaration -> StaticFieldCast())
  1276.                      p -> AddClassVariable(field_declaration);
  1277.                 else p -> AddInstanceVariable(field_declaration);
  1278.             }
  1279.             else if (method_declaration = root -> element -> MethodDeclarationCast())
  1280.             {
  1281.                 p -> AddMethod(method_declaration);
  1282.             }
  1283.             else if (constructor_declaration = root -> element -> ConstructorDeclarationCast())
  1284.             {
  1285.                 p -> AddConstructor(constructor_declaration);
  1286.             }
  1287.             else if (static_initializer = root -> element -> StaticInitializerCast())
  1288.             {
  1289.                 p -> AddStaticInitializer(static_initializer);
  1290.             }
  1291.             else if (class_declaration = root -> element -> ClassDeclarationCast())
  1292.             {
  1293.                 p -> AddNestedClass(class_declaration);
  1294.             }
  1295.             else if (interface_declaration = root -> element -> InterfaceDeclarationCast())
  1296.             {
  1297.                 p -> AddNestedInterface(interface_declaration);
  1298.             }
  1299.             else if (block = root -> element -> BlockCast())
  1300.             {
  1301.                 p -> AddBlock(block);
  1302.             }
  1303.             else // assert(block = root -> element -> EmptyDeclarationCast())
  1304.             {
  1305.                 p -> AddEmptyDeclaration((AstEmptyDeclaration *) root -> element);
  1306.             }
  1307.         } while(root != tail);
  1308.         FreeCircularList(tail);
  1309.     }
  1310.     p -> right_brace_token = Token(3);
  1311.     p -> pool = body_pool; // from now on, this is the storage pool to use for this type
  1312.     Sym(1) = p;
  1313. }
  1314. ./
  1315.  
  1316. ClassBodyDeclarations ::= ClassBodyDeclaration
  1317. \:$action:\
  1318. /.$location
  1319. //
  1320. // Note that the list is circular so as to preserve the order of the elements
  1321. //
  1322. void Parser::Act$rule_number(void)
  1323. {
  1324.     AstListNode *p = AllocateListNode();
  1325.     p -> next = p;
  1326.     p -> element = Sym(1);
  1327.     p -> index = 0;
  1328.  
  1329.     Sym(1) = p;
  1330. }
  1331. ./
  1332.  
  1333. ClassBodyDeclarations ::= ClassBodyDeclarations ClassBodyDeclaration
  1334. \:$action:\
  1335. /.$location
  1336. //
  1337. // Note that the list is circular so as to preserve the order of the elements
  1338. //
  1339. void Parser::Act$rule_number(void)
  1340. {
  1341.     AstListNode *tail = (AstListNode *) Sym(1);
  1342.  
  1343.     AstListNode *p = AllocateListNode();
  1344.     p -> element = Sym(2);
  1345.     p -> index = tail -> index + 1;
  1346.  
  1347.     p -> next = tail -> next;
  1348.     tail -> next = p;
  1349.  
  1350.     Sym(1) = p;
  1351. }
  1352. ./
  1353.  
  1354. ClassBodyDeclaration -> ClassMemberDeclaration
  1355. \:$NoAction:\
  1356. /.$shared_NoAction./
  1357.  
  1358. ClassBodyDeclaration -> StaticInitializer
  1359. \:$NoAction:\
  1360. /.$shared_NoAction./
  1361.  
  1362. ClassBodyDeclaration -> ConstructorDeclaration
  1363. \:$NoAction:\
  1364. /.$shared_NoAction./
  1365.  
  1366. --1.1 feature
  1367. ClassBodyDeclaration ::= MethodHeaderMarker Block
  1368. \:$action:\
  1369. /.$location
  1370. void Parser::Act$rule_number(void)
  1371. {
  1372.     Sym(1) = Sym(2);
  1373. }
  1374. ./
  1375.  
  1376. ClassMemberDeclaration -> FieldDeclaration
  1377. \:$NoAction:\
  1378. /.$shared_NoAction./
  1379.  
  1380. ClassMemberDeclaration -> MethodDeclaration
  1381. \:$NoAction:\
  1382. /.$shared_NoAction./
  1383.  
  1384. --1.1 feature
  1385. ClassMemberDeclaration -> ClassDeclaration
  1386. \:$NoAction:\
  1387. /.$shared_NoAction./
  1388.  
  1389. --1.1 feature
  1390. ClassMemberDeclaration -> InterfaceDeclaration
  1391. \:$NoAction:\
  1392. /.$shared_NoAction./
  1393.  
  1394. --
  1395. -- Empty declarations are not valid Java ClassMemberDeclarations.
  1396. -- However, since the current (2/14/97) Java compiler accepts them 
  1397. -- (in fact, some of the official tests contain this erroneous
  1398. -- syntax), we decided to accept them as valid syntax and flag them
  1399. -- as a warning during semantic processing.
  1400. --
  1401. ClassMemberDeclaration ::= ';'
  1402. \:$action:\
  1403. /.$location
  1404. void Parser::Act$rule_number(void)
  1405. {
  1406.     Sym(1) = ast_pool -> NewEmptyDeclaration(Token(1));
  1407. }
  1408. ./
  1409.  
  1410. --18.8.2 Productions from 8.3: Field Declarations
  1411. --VariableModifier ::=
  1412. --      'public'
  1413. --    | 'protected'
  1414. --    | 'private'
  1415. --    | 'static'
  1416. --    | 'final'
  1417. --    | 'transient'
  1418. --    | 'volatile'
  1419.  
  1420. FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
  1421. \:$action:\
  1422. /.$location
  1423. void Parser::Act$rule_number(void)
  1424. {
  1425.     AstFieldDeclaration *p = ast_pool -> NewFieldDeclaration();
  1426.     if (Sym(1) != NULL)
  1427.     {   
  1428.         AstListNode *tail = (AstListNode *) Sym(1);
  1429.         p -> AllocateVariableModifiers(tail -> index + 1);
  1430.         AstListNode *root = tail;
  1431.         do
  1432.         {
  1433.             root = root -> next;
  1434.             p -> AddVariableModifier((AstModifier *) root -> element);
  1435.         } while(root != tail);
  1436.         FreeCircularList(tail);
  1437.     }
  1438.     p -> type = Sym(2);
  1439.     //
  1440.     // The list of declarators is guaranteed not empty
  1441.     //
  1442.     {   
  1443.         AstListNode *tail = (AstListNode *) Sym(3);
  1444.         p -> AllocateVariableDeclarators(tail -> index + 1);
  1445.         AstListNode *root = tail;
  1446.         do
  1447.         {
  1448.             root = root -> next;
  1449.             p -> AddVariableDeclarator((AstVariableDeclarator *) root -> element);
  1450.         } while(root != tail);
  1451.         FreeCircularList(tail);
  1452.     }
  1453.     p -> semicolon_token      = Token(4);
  1454.     Sym(1) = p;
  1455. }
  1456. ./
  1457.  
  1458. VariableDeclarators ::= VariableDeclarator
  1459. \:$action:\
  1460. /.$location
  1461. //
  1462. // Note that the list is circular so as to preserve the order of the elements
  1463. //
  1464. void Parser::Act$rule_number(void)
  1465. {
  1466.     AstListNode *p = AllocateListNode();
  1467.     p -> next = p;
  1468.     p -> element = Sym(1);
  1469.     p -> index = 0;
  1470.  
  1471.     Sym(1) = p;
  1472. }
  1473. ./
  1474.  
  1475. VariableDeclarators ::= VariableDeclarators ',' VariableDeclarator
  1476. \:$action:\
  1477. /.$location
  1478. //
  1479. // Note that the list is circular so as to preserve the order of the elements
  1480. //
  1481. void Parser::Act$rule_number(void)
  1482. {
  1483.     AstListNode *tail = (AstListNode *) Sym(1);
  1484.  
  1485.     AstListNode *p = AllocateListNode();
  1486.     p -> element = Sym(3);
  1487.     p -> index = tail -> index + 1;
  1488.  
  1489.     p -> next = tail -> next;
  1490.     tail -> next = p;
  1491.  
  1492.     Sym(1) = p;
  1493. }
  1494. ./
  1495.  
  1496. VariableDeclarator ::= VariableDeclaratorId
  1497. \:$action:\
  1498. /.$location
  1499. void Parser::Act$rule_number(void)
  1500. {
  1501.     AstVariableDeclarator *p = ast_pool -> NewVariableDeclarator();
  1502.     p -> variable_declarator_name = (AstVariableDeclaratorId *) Sym(1);
  1503.     p -> variable_initializer_opt = NULL;
  1504.     Sym(1) = p;
  1505. }
  1506. ./
  1507.  
  1508. VariableDeclarator ::= VariableDeclaratorId '=' VariableInitializer
  1509. \:$action:\
  1510. /.$location
  1511. void Parser::Act$rule_number(void)
  1512. {
  1513.     AstVariableDeclarator *p = ast_pool -> NewVariableDeclarator();
  1514.     p -> variable_declarator_name = (AstVariableDeclaratorId *) Sym(1);
  1515.     p -> variable_initializer_opt = Sym(3);
  1516.     Sym(1) = p;
  1517. }
  1518. ./
  1519.  
  1520. VariableDeclaratorId ::= 'Identifier' Dimsopt
  1521. \:$action:\
  1522. /.$location
  1523. void Parser::Act$rule_number(void)
  1524. {
  1525.     AstVariableDeclaratorId *p = ast_pool -> NewVariableDeclaratorId();
  1526.     p -> identifier_token = Token(1);
  1527.     if (Sym(2) != NULL)
  1528.     {
  1529.         AstListNode *tail = (AstListNode *) Sym(2);
  1530.         p -> AllocateBrackets(tail -> index + 1);
  1531.         AstListNode *root = tail;
  1532.         do
  1533.         {
  1534.             root = root -> next;
  1535.             p -> AddBrackets((AstBrackets *) root -> element);
  1536.         } while(root != tail);
  1537.         FreeCircularList(tail);
  1538.     }
  1539.     Sym(1) = p;
  1540. }
  1541. ./
  1542.  
  1543. VariableInitializer -> Expression
  1544. \:$NoAction:\
  1545. /.$shared_NoAction./
  1546.  
  1547. VariableInitializer -> ArrayInitializer
  1548. \:$NoAction:\
  1549. /.$shared_NoAction./
  1550.  
  1551. --18.8.3 Productions from 8.4: Method Declarations
  1552. --MethodModifier ::=
  1553. --      'public'
  1554. --    | 'protected'
  1555. --    | 'private'
  1556. --    | 'static'
  1557. --    | 'abstract'
  1558. --    | 'final'
  1559. --    | 'native'
  1560. --    | 'synchronized'
  1561. --
  1562. -- The original rule does not contain the "MethodHeaderMarker.
  1563. -- See explanation above.
  1564. --
  1565. -- MethodDeclaration ::= MethodHeader MethodBody
  1566. --
  1567.  
  1568. MethodDeclaration ::= MethodHeader MethodHeaderMarker MethodBody
  1569. \:$action:\
  1570. /.$location
  1571. void Parser::Act$rule_number(void)
  1572. {
  1573.     ((AstMethodDeclaration *) Sym(1)) -> method_body = (AstStatement *) Sym(3);
  1574. }
  1575. ./
  1576.  
  1577. MethodHeader ::= Modifiersopt Type MethodDeclarator Throwsopt
  1578. \:$action:\
  1579. /.$location
  1580. void Parser::Act$rule_number(void)
  1581. {
  1582.     AstMethodDeclaration *p = ast_pool -> NewMethodDeclaration();
  1583.     if (Sym(1) != NULL)
  1584.     {   
  1585.         AstListNode *tail = (AstListNode *) Sym(1);
  1586.         p -> AllocateMethodModifiers(tail -> index + 1);
  1587.         AstListNode *root = tail;
  1588.         do
  1589.         {
  1590.             root = root -> next;
  1591.             p -> AddMethodModifier((AstModifier *) root -> element);
  1592.         } while(root != tail);
  1593.         FreeCircularList(tail);
  1594.     }
  1595.     p -> type              = Sym(2);
  1596.     p -> method_declarator = (AstMethodDeclarator *) Sym(3);
  1597.     if (Sym(4) != NULL)
  1598.     {   
  1599.         AstListNode *tail = (AstListNode *) Sym(4);
  1600.         p -> AllocateThrows(tail -> index + 1);
  1601.         AstListNode *root = tail;
  1602.         do
  1603.         {
  1604.             root = root -> next;
  1605.             p -> AddThrow((AstExpression *) root -> element);
  1606.         } while(root != tail);
  1607.         FreeCircularList(tail);
  1608.     }
  1609.     Sym(1) = p;
  1610. }
  1611. ./
  1612.  
  1613. MethodHeader ::= Modifiersopt 'void' MethodDeclarator Throwsopt
  1614. \:$action:\
  1615. /.$location
  1616. void Parser::Act$rule_number(void)
  1617. {
  1618.     AstMethodDeclaration *p = ast_pool -> NewMethodDeclaration();
  1619.     if (Sym(1) != NULL)
  1620.     {   
  1621.         AstListNode *tail = (AstListNode *) Sym(1);
  1622.         p -> AllocateMethodModifiers(tail -> index + 1);
  1623.         AstListNode *root = tail;
  1624.         do
  1625.         {
  1626.             root = root -> next;
  1627.             p -> AddMethodModifier((AstModifier *) root -> element);
  1628.         } while(root != tail);
  1629.         FreeCircularList(tail);
  1630.     }
  1631.     p -> type              = ast_pool -> NewPrimitiveType(Ast::VOID_TYPE, Token(2));
  1632.     p -> method_declarator = (AstMethodDeclarator *) Sym(3);
  1633.     if (Sym(4) != NULL)
  1634.     {   
  1635.         AstListNode *tail = (AstListNode *) Sym(4);
  1636.         p -> AllocateThrows(tail -> index + 1);
  1637.         AstListNode *root = tail;
  1638.         do
  1639.         {
  1640.             root = root -> next;
  1641.             p -> AddThrow((AstExpression *) root -> element);
  1642.         } while(root != tail);
  1643.         FreeCircularList(tail);
  1644.     }
  1645.     Sym(1) = p;
  1646. }
  1647. ./
  1648.  
  1649. MethodDeclarator ::= 'Identifier' '(' FormalParameterListopt ')' Dimsopt
  1650. \:$action:\
  1651. /.$location
  1652. void Parser::Act$rule_number(void)
  1653. {
  1654.     AstMethodDeclarator *p = ast_pool -> NewMethodDeclarator();
  1655.     p -> identifier_token        = Token(1);
  1656.     p -> left_parenthesis_token  = Token(2);
  1657.     if (Sym(3) != NULL)
  1658.     {   
  1659.         AstListNode *tail = (AstListNode *) Sym(3);
  1660.         p -> AllocateFormalParameters(tail -> index + 1);
  1661.         AstListNode *root = tail;
  1662.         do
  1663.         {
  1664.             root = root -> next;
  1665.             p -> AddFormalParameter((AstFormalParameter *) root -> element);
  1666.         } while(root != tail);
  1667.         FreeCircularList(tail);
  1668.     }
  1669.     p -> right_parenthesis_token = Token(4);
  1670.     if (Sym(5) != NULL)
  1671.     {
  1672.         AstListNode *tail = (AstListNode *) Sym(5);
  1673.         p -> AllocateBrackets(tail -> index + 1);
  1674.         AstListNode *root = tail;
  1675.         do
  1676.         {
  1677.             root = root -> next;
  1678.             p -> AddBrackets((AstBrackets *) root -> element);
  1679.         } while(root != tail);
  1680.         FreeCircularList(tail);
  1681.     }
  1682.     Sym(1) = p;
  1683. }
  1684. ./
  1685.  
  1686. FormalParameterList ::= FormalParameter
  1687. \:$action:\
  1688. /.$location
  1689. //
  1690. // Note that the list is circular so as to preserve the order of the elements
  1691. //
  1692. void Parser::Act$rule_number(void)
  1693. {
  1694.     AstListNode *p = AllocateListNode();
  1695.     p -> next = p;
  1696.     p -> element = Sym(1);
  1697.     p -> index = 0;
  1698.  
  1699.     Sym(1) = p;
  1700. }
  1701. ./
  1702.  
  1703. FormalParameterList ::= FormalParameterList ',' FormalParameter
  1704. \:$action:\
  1705. /.$location
  1706. //
  1707. // Note that the list is circular so as to preserve the order of the elements
  1708. //
  1709. void Parser::Act$rule_number(void)
  1710. {
  1711.     AstListNode *tail = (AstListNode *) Sym(1);
  1712.  
  1713.     AstListNode *p = AllocateListNode();
  1714.     p -> element = Sym(3);
  1715.     p -> index = tail -> index + 1;
  1716.  
  1717.     p -> next = tail -> next;
  1718.     tail -> next = p;
  1719.  
  1720.     Sym(1) = p;
  1721. }
  1722. ./
  1723.  
  1724. FormalParameter ::= Type VariableDeclaratorId
  1725. \:$action:\
  1726. /.$location
  1727. void Parser::Act$rule_number(void)
  1728. {
  1729.     AstFormalParameter *p = ast_pool -> NewFormalParameter();
  1730.     p -> type                     = Sym(1);
  1731.     p -> variable_declarator_name = (AstVariableDeclaratorId *) Sym(2);
  1732.     Sym(1) = p;
  1733. }
  1734. ./
  1735.  
  1736. --1.1 feature
  1737. FormalParameter ::= Modifiers Type VariableDeclaratorId
  1738. \:$action:\
  1739. /.$location
  1740. void Parser::Act$rule_number(void)
  1741. {
  1742.     AstFormalParameter *p = ast_pool -> NewFormalParameter();
  1743.     //
  1744.     // The list of modifiers is guaranteed not empty
  1745.     //
  1746.     {   
  1747.         AstListNode *tail = (AstListNode *) Sym(1);
  1748.         p -> AllocateParameterModifiers(tail -> index + 1);
  1749.         AstListNode *root = tail;
  1750.         do
  1751.         {
  1752.             root = root -> next;
  1753.             p -> AddParameterModifier((AstModifier *) root -> element);
  1754.         } while(root != tail);
  1755.         FreeCircularList(tail);
  1756.     }
  1757.     p -> type                     = Sym(2);
  1758.     p -> variable_declarator_name = (AstVariableDeclaratorId *) Sym(3);
  1759.     Sym(1) = p;
  1760. }
  1761. ./
  1762.  
  1763. Throws ::= 'throws' ClassTypeList
  1764. \:$SetSym1ToSym2:\
  1765. /.$shared_function
  1766. //
  1767. // void SetSym1ToSym2(void);
  1768. //./
  1769.  
  1770. ClassTypeList ::= ClassType
  1771. \:$action:\
  1772. /.$location
  1773. //
  1774. // Note that the list is circular so as to preserve the order of the elements
  1775. //
  1776. void Parser::Act$rule_number(void)
  1777. {
  1778.     AstListNode *p = AllocateListNode();
  1779.     p -> next = p;
  1780.     p -> element = Sym(1);
  1781.     p -> index = 0;
  1782.  
  1783.     Sym(1) = p;
  1784. }
  1785. ./
  1786.  
  1787. ClassTypeList ::= ClassTypeList ',' ClassType
  1788. \:$action:\
  1789. /.$location
  1790. //
  1791. // Note that the list is circular so as to preserve the order of the elements
  1792. //
  1793. void Parser::Act$rule_number(void)
  1794. {
  1795.     AstListNode *tail = (AstListNode *) Sym(1);
  1796.  
  1797.     AstListNode *p = AllocateListNode();
  1798.     p -> element = Sym(3);
  1799.     p -> index = tail -> index + 1;
  1800.  
  1801.     p -> next = tail -> next;
  1802.     tail -> next = p;
  1803.  
  1804.     Sym(1) = p;
  1805. }
  1806. ./
  1807.  
  1808. MethodBody -> Block
  1809. \:$NoAction:\
  1810. /.$shared_NoAction./
  1811.  
  1812. MethodBody ::= ';'
  1813. \:$MakeEmptyStatement:\
  1814. /.$location
  1815. void Parser::MakeEmptyStatement(void)
  1816. {
  1817.     Sym(1) = ast_pool -> NewEmptyStatement(Token(1));
  1818. }
  1819. ./
  1820.  
  1821. --18.8.4 Productions from 8.5: Static Initializers
  1822.  
  1823. StaticInitializer ::= 'static' MethodHeaderMarker Block
  1824. \:$action:\
  1825. /.$location
  1826. void Parser::Act$rule_number(void)
  1827. {
  1828.     AstStaticInitializer *p = ast_pool -> NewStaticInitializer();
  1829.     p -> static_token = Token(1);
  1830.     p -> block        = (AstBlock *) Sym(3);
  1831.     Sym(1) = p;
  1832. }
  1833. ./
  1834.  
  1835. --18.8.5 Productions from 8.6: Constructor Declarations
  1836. --ConstructorModifier ::=
  1837. --      'public'
  1838. --    | 'protected'
  1839. --    | 'private'
  1840. --
  1841. --
  1842. -- The original rule does not contain a "MethodHeaderMarker". See
  1843. -- explanation above.
  1844. --
  1845. -- ConstructorDeclaration ::= Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody
  1846. --
  1847.  
  1848. ConstructorDeclaration ::= Modifiersopt ConstructorDeclarator Throwsopt MethodHeaderMarker ConstructorBody
  1849. \:$action:\
  1850. /.$location
  1851. void Parser::Act$rule_number(void)
  1852. {
  1853.     AstConstructorBlock *block = Sym(5) -> ConstructorBlockCast();
  1854.     if (! block)
  1855.     {
  1856.         block = ast_pool -> NewConstructorBlock();
  1857.         block -> left_brace_token                    = Sym(5) -> LeftToken();
  1858.         block -> explicit_constructor_invocation_opt = NULL;
  1859.         block -> block                               = (AstBlock *) Sym(5);
  1860.         block -> right_brace_token                   = Sym(5) -> RightToken();
  1861.     }
  1862.  
  1863.     AstConstructorDeclaration *p = ast_pool -> NewConstructorDeclaration();
  1864.  
  1865.     if (Sym(1) != NULL)
  1866.     {   
  1867.         AstListNode *tail = (AstListNode *) Sym(1);
  1868.         p -> AllocateConstructorModifiers(tail -> index + 1);
  1869.         AstListNode *root = tail;
  1870.         do
  1871.         {
  1872.             root = root -> next;
  1873.             p -> AddConstructorModifier((AstModifier *) root -> element);
  1874.         } while(root != tail);
  1875.         FreeCircularList(tail);
  1876.     }
  1877.     p -> constructor_declarator = (AstMethodDeclarator *) Sym(2);
  1878.     if (Sym(3) != NULL)
  1879.     {   
  1880.         AstListNode *tail = (AstListNode *) Sym(3);
  1881.         p -> AllocateThrows(tail -> index + 1);
  1882.         AstListNode *root = tail;
  1883.         do
  1884.         {
  1885.             root = root -> next;
  1886.             p -> AddThrow((AstExpression *) root -> element);
  1887.         } while(root != tail);
  1888.         FreeCircularList(tail);
  1889.     }
  1890.     p -> constructor_body       = block;
  1891.  
  1892.     Sym(1) = p;
  1893. }
  1894. ./
  1895.  
  1896. --
  1897. -- The original rule specifies SimpleName but it appears to be an
  1898. -- error as the rule for a method declarator uses an Identifier.
  1899. --...Until further notice, ...
  1900. --
  1901. -- ConstructorDeclarator ::= SimpleName '(' FormalParameterListopt ')'
  1902. --
  1903.  
  1904. ConstructorDeclarator ::= 'Identifier' '(' FormalParameterListopt ')'
  1905. \:$action:\
  1906. /.$location
  1907. void Parser::Act$rule_number(void)
  1908. {
  1909.     AstMethodDeclarator *p = ast_pool -> NewMethodDeclarator();
  1910.     p -> identifier_token        = Token(1);
  1911.     p -> left_parenthesis_token  = Token(2);
  1912.     if (Sym(3) != NULL)
  1913.     {   
  1914.         AstListNode *tail = (AstListNode *) Sym(3);
  1915.         p -> AllocateFormalParameters(tail -> index + 1);
  1916.         AstListNode *root = tail;
  1917.         do
  1918.         {
  1919.             root = root -> next;
  1920.             p -> AddFormalParameter((AstFormalParameter *) root -> element);
  1921.         } while(root != tail);
  1922.         FreeCircularList(tail);
  1923.     }
  1924.     p -> right_parenthesis_token = Token(4);
  1925.     Sym(1) = p;
  1926. }
  1927. ./
  1928.  
  1929. --
  1930. -- NOTE that the rules ExplicitConstructorInvocationopt has been expanded
  1931. -- in the rule below in order to make the grammar lalr(1).
  1932. --
  1933. -- ConstructorBody ::= '{' ExplicitConstructorInvocationopt BlockStatementsopt '}'
  1934. -- 
  1935. ConstructorBody -> Block
  1936. \:$NoAction:\
  1937. /.$shared_NoAction./
  1938.  
  1939. ConstructorBody ::= '{' ExplicitConstructorInvocation BlockStatementsopt '}'
  1940. \:$action:\
  1941. /.$location
  1942. void Parser::Act$rule_number(void)
  1943. {
  1944.     AstBlock *block = ast_pool -> NewBlock();
  1945.     if (Sym(3) != NULL)
  1946.     {
  1947.         AstListNode *tail = (AstListNode *) Sym(3);
  1948.         block -> AllocateBlockStatements(tail -> index + 1);
  1949.         AstListNode *root = tail;
  1950.         block -> left_brace_token  = root -> element -> LeftToken();
  1951.         block -> right_brace_token = tail -> element -> RightToken();
  1952.         do
  1953.         {
  1954.             root = root -> next;
  1955.             block -> AddStatement((AstStatement *) root -> element);
  1956.         } while(root != tail);
  1957.         FreeCircularList(tail);
  1958.     }
  1959.     else
  1960.     {
  1961.         block -> left_brace_token  = Token(4);
  1962.         block -> right_brace_token = Token(4);
  1963.     }
  1964.  
  1965.     AstConstructorBlock *p = ast_pool -> NewConstructorBlock();
  1966.     p -> left_brace_token                    = Token(1);
  1967.     p -> explicit_constructor_invocation_opt = Sym(2);
  1968.     p -> block                               = block;
  1969.     p -> right_brace_token                   = Token(4);
  1970.     Sym(1) = p;
  1971. }
  1972. ./
  1973.  
  1974. ExplicitConstructorInvocation ::= 'this' '(' ArgumentListopt ')' ';'
  1975. \:$action:\
  1976. /.$location
  1977. void Parser::Act$rule_number(void)
  1978. {
  1979.     AstThisCall *p = ast_pool -> NewThisCall();
  1980.     p -> base_opt                = NULL;
  1981.     p -> dot_token_opt           = 0;
  1982.     p -> this_token              = Token(1);
  1983.     p -> left_parenthesis_token  = Token(2);
  1984.     if (Sym(3) != NULL)
  1985.     {
  1986.         AstListNode *tail = (AstListNode *) Sym(3);
  1987.         p -> AllocateArguments(tail -> index + 1);
  1988.         AstListNode *root = tail;
  1989.         do
  1990.         {
  1991.             root = root -> next;
  1992.             p -> AddArgument((AstExpression *) root -> element);
  1993.         } while(root != tail);
  1994.         FreeCircularList(tail);
  1995.     }
  1996.     p -> right_parenthesis_token = Token(4);
  1997.     p -> semicolon_token         = Token(5);
  1998.     Sym(1) = p;
  1999. }
  2000. ./
  2001.  
  2002. ExplicitConstructorInvocation ::= 'super' '(' ArgumentListopt ')' ';'
  2003. \:$action:\
  2004. /.$location
  2005. void Parser::Act$rule_number(void)
  2006. {
  2007.     AstSuperCall *p = ast_pool -> NewSuperCall();
  2008.     p -> base_opt                = NULL;
  2009.     p -> dot_token_opt           = 0;
  2010.     p -> super_token             = Token(1);
  2011.     p -> left_parenthesis_token  = Token(2);
  2012.     if (Sym(3) != NULL)
  2013.     {
  2014.         AstListNode *tail = (AstListNode *) Sym(3);
  2015.         p -> AllocateArguments(tail -> index + 1);
  2016.         AstListNode *root = tail;
  2017.         do
  2018.         {
  2019.             root = root -> next;
  2020.             p -> AddArgument((AstExpression *) root -> element);
  2021.         } while(root != tail);
  2022.         FreeCircularList(tail);
  2023.     }
  2024.     p -> right_parenthesis_token = Token(4);
  2025.     p -> semicolon_token         = Token(5);
  2026.     Sym(1) = p;
  2027. }
  2028. ./
  2029.  
  2030. --1.2 feature
  2031. ExplicitConstructorInvocation ::= Primary '.' 'this' '(' ArgumentListopt ')' ';'
  2032. \:$action:\
  2033. /.$location
  2034. void Parser::Act$rule_number(void)
  2035. {
  2036.     AstThisCall *p = ast_pool -> NewThisCall();
  2037.     p -> base_opt               = (AstExpression *) Sym(1);
  2038.     p -> dot_token_opt          = Token(2);
  2039.     p -> this_token             = Token(3);
  2040.     p -> left_parenthesis_token = Token(4);
  2041.     if (Sym(5) != NULL)
  2042.     {
  2043.         AstListNode *tail = (AstListNode *) Sym(5);
  2044.         p -> AllocateArguments(tail -> index + 1);
  2045.         AstListNode *root = tail;
  2046.         do
  2047.         {
  2048.             root = root -> next;
  2049.             p -> AddArgument((AstExpression *) root -> element);
  2050.         } while(root != tail);
  2051.         FreeCircularList(tail);
  2052.     }
  2053.     p -> right_parenthesis_token = Token(6);
  2054.     p -> semicolon_token         = Token(7);
  2055.     Sym(1) = p;
  2056. }
  2057. ./
  2058.  
  2059. --1.1 feature
  2060. ExplicitConstructorInvocation ::= Primary '.' 'super' '(' ArgumentListopt ')' ';'
  2061. \:$MakeQualifiedSuper:\
  2062. /.$location
  2063. void Parser::MakeQualifiedSuper(void)
  2064. {
  2065.     AstSuperCall *p = ast_pool -> NewSuperCall();
  2066.     p -> base_opt                = (AstExpression *) Sym(1);
  2067.     p -> dot_token_opt           = Token(2);
  2068.     p -> super_token             = Token(3);
  2069.     p -> left_parenthesis_token  = Token(4);
  2070.     if (Sym(5) != NULL)
  2071.     {
  2072.         AstListNode *tail = (AstListNode *) Sym(5);
  2073.         p -> AllocateArguments(tail -> index + 1);
  2074.         AstListNode *root = tail;
  2075.         do
  2076.         {
  2077.             root = root -> next;
  2078.             p -> AddArgument((AstExpression *) root -> element);
  2079.         } while(root != tail);
  2080.         FreeCircularList(tail);
  2081.     }
  2082.     p -> right_parenthesis_token = Token(6);
  2083.     p -> semicolon_token         = Token(7);
  2084.     Sym(1) = p;
  2085. }
  2086. ./
  2087.  
  2088. --1.1 feature
  2089. ExplicitConstructorInvocation ::= Name '.' 'super' '(' ArgumentListopt ')' ';'
  2090. \:$MakeQualifiedSuper:\
  2091. /.$shared_function
  2092. //
  2093. // void MakeQualifiedSuper(void);
  2094. //./
  2095.  
  2096. --18.9 Productions from 9: Interface Declarations
  2097.  
  2098. --18.9.1 Productions from 9.1: Interface Declarations
  2099. --InterfaceModifier ::=
  2100. --      'public'
  2101. --    | 'abstract'
  2102. --
  2103. InterfaceDeclaration ::= Modifiersopt 'interface' 'Identifier' ExtendsInterfacesopt InterfaceBody
  2104. \:$action:\
  2105. /.$location
  2106. void Parser::Act$rule_number(void)
  2107. {
  2108.     AstInterfaceDeclaration *p = (AstInterfaceDeclaration *) Sym(5);
  2109.     if (Sym(1) != NULL)
  2110.     {   
  2111.         AstListNode *tail = (AstListNode *) Sym(1);
  2112.         p -> AllocateInterfaceModifiers(tail -> index + 1);
  2113.         AstListNode *root = tail;
  2114.         do
  2115.         {
  2116.             root = root -> next;
  2117.             p -> AddInterfaceModifier((AstModifier *) root -> element);
  2118.         } while(root != tail);
  2119.         FreeCircularList(tail);
  2120.     }
  2121.     p -> interface_token  = Token(2);
  2122.     p -> identifier_token = Token(3);
  2123.     if (Sym(4) != NULL)
  2124.     {
  2125.         AstListNode *tail = (AstListNode *) Sym(4);
  2126.         p -> AllocateExtendsInterfaces(tail -> index + 1);
  2127.         AstListNode *root = tail;
  2128.         do
  2129.         {
  2130.             root = root -> next;
  2131.             p -> AddExtendsInterface((AstExpression *) root -> element);
  2132.         } while(root != tail);
  2133.         FreeCircularList(tail);
  2134.     }
  2135.     Sym(1) = p;
  2136. }
  2137. ./
  2138.  
  2139. ExtendsInterfaces ::= 'extends' InterfaceTypeList
  2140. \:$SetSym1ToSym2:\
  2141. /.$shared_function
  2142. //
  2143. // void SetSym1ToSym2(void);
  2144. //./
  2145.  
  2146. InterfaceBody ::= '{' InterfaceMemberDeclarationsopt '}'
  2147. \:$action:\
  2148. /.$location
  2149. void Parser::Act$rule_number(void)
  2150. {
  2151.     AstInterfaceDeclaration *p = ast_pool -> NewInterfaceDeclaration();
  2152.     if (parse_header_only)
  2153.         p -> mark_unparsed();
  2154.  
  2155.     p -> left_brace_token = Token(1);
  2156.     if (Sym(2) != NULL)
  2157.     {   
  2158.         int num_class_variables = 0,
  2159.             num_methods = 0,
  2160.             num_inner_classes = 0,
  2161.             num_inner_interfaces = 0,
  2162.             num_empty_declarations = 0;
  2163.  
  2164.         AstListNode *tail = (AstListNode *) Sym(2);
  2165.         p -> AllocateInterfaceMemberDeclarations(tail -> index + 1);
  2166.         AstListNode *root = tail;
  2167.         do
  2168.         {
  2169.             root = root -> next;
  2170.             p -> AddInterfaceMemberDeclaration(root -> element);
  2171.  
  2172.             AstFieldDeclaration *field_declaration = root -> element -> FieldDeclarationCast();
  2173.             if (field_declaration)
  2174.             {
  2175.                 field_declaration -> MarkStatic();
  2176.                 num_class_variables++;
  2177.             }
  2178.             else if (root -> element -> MethodDeclarationCast())
  2179.             {
  2180.                 num_methods++;
  2181.             }
  2182.             else if (root -> element -> ClassDeclarationCast())
  2183.             {
  2184.                 num_inner_classes++;
  2185.             }
  2186.             else if (root -> element -> InterfaceDeclarationCast())
  2187.             {
  2188.                 num_inner_interfaces++;
  2189.             }
  2190.             else num_empty_declarations++;
  2191.         } while(root != tail);
  2192.  
  2193.         p -> AllocateClassVariables(num_class_variables);
  2194.         p -> AllocateMethods(num_methods);
  2195.         p -> AllocateNestedClasses(num_inner_classes);
  2196.         p -> AllocateNestedInterfaces(num_inner_interfaces);
  2197.         p -> AllocateEmptyDeclarations(num_empty_declarations);
  2198.  
  2199.         root = tail;
  2200.         do
  2201.         {
  2202.             root = root -> next;
  2203.  
  2204.             AstFieldDeclaration *field_declaration;
  2205.             AstMethodDeclaration *method_declaration;
  2206.             AstClassDeclaration *class_declaration;
  2207.             AstInterfaceDeclaration *interface_declaration;
  2208.  
  2209.             if (field_declaration = root -> element -> FieldDeclarationCast())
  2210.             {
  2211.                 p -> AddClassVariable(field_declaration);
  2212.             }
  2213.             else if (method_declaration = root -> element -> MethodDeclarationCast())
  2214.             {
  2215.                 p -> AddMethod(method_declaration);
  2216.             }
  2217.             else if (class_declaration = root -> element -> ClassDeclarationCast())
  2218.             {
  2219.                 p -> AddNestedClass(class_declaration);
  2220.             }
  2221.             else if (interface_declaration = root -> element -> InterfaceDeclarationCast())
  2222.             {
  2223.                 p -> AddNestedInterface(interface_declaration);
  2224.             }
  2225.             else // assert(interface_declaration = root -> element -> EmptyDeclarationCast())
  2226.             {
  2227.                 p -> AddEmptyDeclaration((AstEmptyDeclaration *) root -> element);
  2228.             }
  2229.         } while(root != tail);
  2230.         FreeCircularList(tail);
  2231.     }
  2232.     p -> right_brace_token = Token(3);
  2233.     p -> pool = body_pool; // from now on, this is the storage pool to use for this type
  2234.     Sym(1) = p;
  2235. }
  2236. ./
  2237.  
  2238. InterfaceMemberDeclarations ::= InterfaceMemberDeclaration
  2239. \:$action:\
  2240. /.$location
  2241. //
  2242. // Note that the list is circular so as to preserve the order of the elements
  2243. //
  2244. void Parser::Act$rule_number(void)
  2245. {
  2246.     AstListNode *p = AllocateListNode();
  2247.     p -> next = p;
  2248.     p -> element = Sym(1);
  2249.     p -> index = 0;
  2250.  
  2251.     Sym(1) = p;
  2252. }
  2253. ./
  2254.  
  2255. InterfaceMemberDeclarations ::= InterfaceMemberDeclarations InterfaceMemberDeclaration
  2256. \:$action:\
  2257. /.$location
  2258. //
  2259. // Note that the list is circular so as to preserve the order of the elements
  2260. //
  2261. void Parser::Act$rule_number(void)
  2262. {
  2263.     AstListNode *tail = (AstListNode *) Sym(1);
  2264.  
  2265.     AstListNode *p = AllocateListNode();
  2266.     p -> element = Sym(2);
  2267.     p -> index = tail -> index + 1;
  2268.  
  2269.     p -> next = tail -> next;
  2270.     tail -> next = p;
  2271.  
  2272.     Sym(1) = p;
  2273. }
  2274. ./
  2275.  
  2276. InterfaceMemberDeclaration -> ConstantDeclaration
  2277. \:$NoAction:\
  2278. /.$shared_NoAction./
  2279.  
  2280. InterfaceMemberDeclaration -> AbstractMethodDeclaration
  2281. \:$NoAction:\
  2282. /.$shared_NoAction./
  2283.  
  2284. --1.1 feature
  2285. InterfaceMemberDeclaration -> ClassDeclaration
  2286. \:$NoAction:\
  2287. /.$shared_NoAction./
  2288.  
  2289. --1.1 feature
  2290. InterfaceMemberDeclaration -> InterfaceDeclaration
  2291. \:$NoAction:\
  2292. /.$shared_NoAction./
  2293.  
  2294. --
  2295. -- Empty declarations are not valid Java InterfaceMemberDeclarations.
  2296. -- However, since the current (2/14/97) Java compiler accepts them 
  2297. -- (in fact, some of the official tests contain this erroneous
  2298. -- syntax), we decided to accept them as valid syntax and flag them
  2299. -- as a warning during semantic processing.
  2300. --
  2301. InterfaceMemberDeclaration ::= ';'
  2302. \:$action:\
  2303. /.$location
  2304. void Parser::Act$rule_number(void)
  2305. {
  2306.     Sym(1) = ast_pool -> NewEmptyDeclaration(Token(1));
  2307. }
  2308. ./
  2309.  
  2310. ConstantDeclaration -> FieldDeclaration
  2311. \:$NoAction:\
  2312. /.$shared_NoAction./
  2313.  
  2314. AbstractMethodDeclaration ::= MethodHeader ';'
  2315. \:$action:\
  2316. /.$location
  2317. void Parser::Act$rule_number(void)
  2318. {
  2319.     ((AstMethodDeclaration *) Sym(1)) -> method_body = ast_pool -> NewEmptyStatement(Token(2));
  2320. }
  2321. ./
  2322.  
  2323. --18.10 Productions from 10: Arrays
  2324.  
  2325. --
  2326. -- NOTE that the rules VariableInitializersopt and ,opt have been expanded,
  2327. -- where appropriate, in the rule below in order to make the grammar lalr(1).
  2328. --
  2329. -- ArrayInitializer ::= '{' VariableInitializersopt ,opt '}'
  2330. --
  2331. ArrayInitializer ::= '{' ,opt '}'
  2332. \:$action:\
  2333. /.$location
  2334. void Parser::Act$rule_number(void)
  2335. {
  2336.     AstArrayInitializer *p = ast_pool -> NewArrayInitializer();
  2337.     p -> left_brace_token      = Token(1);
  2338.     p -> right_brace_token     = Token(3);
  2339.     Sym(1) = p;
  2340. }
  2341. ./
  2342.  
  2343. ArrayInitializer ::= '{' VariableInitializers '}'
  2344. \:$action:\
  2345. /.$location
  2346. void Parser::Act$rule_number(void)
  2347. {
  2348.     AstArrayInitializer *p = ast_pool -> NewArrayInitializer();
  2349.     p -> left_brace_token      = Token(1);
  2350.     if (Sym(2) != NULL)
  2351.     {
  2352.         AstListNode *tail = (AstListNode *) Sym(2);
  2353.         p -> AllocateVariableInitializers(tail -> index + 1);
  2354.         AstListNode *root = tail;
  2355.         do
  2356.         {
  2357.             root = root -> next;
  2358.             p -> AddVariableInitializer(root -> element);
  2359.         } while(root != tail);
  2360.         FreeCircularList(tail);
  2361.     }
  2362.     p -> right_brace_token     = Token(3);
  2363.     Sym(1) = p;
  2364. }
  2365. ./
  2366.  
  2367. ArrayInitializer ::= '{' VariableInitializers , '}'
  2368. \:$action:\
  2369. /.$location
  2370. void Parser::Act$rule_number(void)
  2371. {
  2372.     AstArrayInitializer *p = ast_pool -> NewArrayInitializer();
  2373.     p -> left_brace_token      = Token(1);
  2374.     if (Sym(2) != NULL)
  2375.     {
  2376.         AstListNode *tail = (AstListNode *) Sym(2);
  2377.         p -> AllocateVariableInitializers(tail -> index + 1);
  2378.         AstListNode *root = tail;
  2379.         do
  2380.         {
  2381.             root = root -> next;
  2382.             p -> AddVariableInitializer(root -> element);
  2383.         } while(root != tail);
  2384.         FreeCircularList(tail);
  2385.     }
  2386.     p -> right_brace_token     = Token(4);
  2387.     Sym(1) = p;
  2388. }
  2389. ./
  2390.  
  2391. VariableInitializers ::= VariableInitializer
  2392. \:$action:\
  2393. /.$location
  2394. //
  2395. // Note that the list is circular so as to preserve the order of the elements
  2396. //
  2397. void Parser::Act$rule_number(void)
  2398. {
  2399.     AstListNode *p = AllocateListNode();
  2400.     p -> next = p;
  2401.     p -> element = Sym(1);
  2402.     p -> index = 0;
  2403.  
  2404.     Sym(1) = p;
  2405. }
  2406. ./
  2407.  
  2408. VariableInitializers ::= VariableInitializers ',' VariableInitializer
  2409. \:$action:\
  2410. /.$location
  2411. //
  2412. // Note that the list is circular so as to preserve the order of the elements
  2413. //
  2414. void Parser::Act$rule_number(void)
  2415. {
  2416.     AstListNode *tail = (AstListNode *) Sym(1);
  2417.  
  2418.     AstListNode *p = AllocateListNode();
  2419.     p -> element = Sym(3);
  2420.     p -> index = tail -> index + 1;
  2421.  
  2422.     p -> next = tail -> next;
  2423.     tail -> next = p;
  2424.  
  2425.     Sym(1) = p;
  2426. }
  2427. ./
  2428.  
  2429. --18.11 Productions from 13: Blocks and Statements
  2430.  
  2431. Block ::= '{' BlockStatementsopt '}'
  2432. \:$action:\
  2433. /.$location
  2434. void Parser::Act$rule_number(void)
  2435. {
  2436.     AstBlock *p = ast_pool -> NewBlock();
  2437.     p -> left_brace_token  = Token(1);
  2438.     if (Sym(2) != NULL)
  2439.     {
  2440.         AstListNode *tail = (AstListNode *) Sym(2);
  2441.         p -> AllocateBlockStatements(tail -> index + 1);
  2442.         AstListNode *root = tail;
  2443.         do
  2444.         {
  2445.             root = root -> next;
  2446.             p -> AddStatement((AstStatement *) root -> element);
  2447.         } while(root != tail);
  2448.         FreeCircularList(tail);
  2449.     }
  2450.     p -> right_brace_token = Token(3);
  2451.     Sym(1) = p;
  2452. }
  2453. ./
  2454.  
  2455. BlockStatements ::= BlockStatement
  2456. \:$action:\
  2457. /.$location
  2458. //
  2459. // Note that the list is circular so as to preserve the order of the elements
  2460. //
  2461. void Parser::Act$rule_number(void)
  2462. {
  2463.     AstListNode *p = AllocateListNode();
  2464.     p -> next = p;
  2465.     p -> element = Sym(1);
  2466.     p -> index = 0;
  2467.  
  2468.     Sym(1) = p;
  2469. }
  2470. ./
  2471.  
  2472. BlockStatements ::= BlockStatements BlockStatement
  2473. \:$action:\
  2474. /.$location
  2475. //
  2476. // Note that the list is circular so as to preserve the order of the elements
  2477. //
  2478. void Parser::Act$rule_number(void)
  2479. {
  2480.     AstListNode *tail = (AstListNode *) Sym(1);
  2481.  
  2482.     AstListNode *p = AllocateListNode();
  2483.     p -> element = Sym(2);
  2484.     p -> index = tail -> index + 1;
  2485.  
  2486.     p -> next = tail -> next;
  2487.     tail -> next = p;
  2488.  
  2489.     Sym(1) = p;
  2490. }
  2491. ./
  2492.  
  2493. BlockStatement -> LocalVariableDeclarationStatement
  2494. \:$NoAction:\
  2495. /.$shared_NoAction./
  2496.  
  2497. BlockStatement -> Statement
  2498. \:$NoAction:\
  2499. /.$shared_NoAction./
  2500.  
  2501. --1.1 feature
  2502. BlockStatement -> ClassDeclaration
  2503. \:$NoAction:\
  2504. /.$shared_NoAction./
  2505.  
  2506. LocalVariableDeclarationStatement ::= LocalVariableDeclaration ';'
  2507. \:$action:\
  2508. /.$location
  2509. void Parser::Act$rule_number(void)
  2510. {
  2511.     ((AstLocalVariableDeclarationStatement *) Sym(1)) -> semicolon_token_opt = Token(2);
  2512. }
  2513. ./
  2514.  
  2515. LocalVariableDeclaration ::= Type VariableDeclarators
  2516. \:$action:\
  2517. /.$location
  2518. void Parser::Act$rule_number(void)
  2519. {
  2520.     AstLocalVariableDeclarationStatement *p = ast_pool -> NewLocalVariableDeclarationStatement();
  2521.     p -> type                 = Sym(1);
  2522.     //
  2523.     // The list of declarators is guaranteed not empty
  2524.     //
  2525.     {   
  2526.         AstListNode *tail = (AstListNode *) Sym(2);
  2527.         p -> AllocateVariableDeclarators(tail -> index + 1);
  2528.         AstListNode *root = tail;
  2529.         do
  2530.         {
  2531.             root = root -> next;
  2532.             p -> AddVariableDeclarator((AstVariableDeclarator *) root -> element);
  2533.         } while(root != tail);
  2534.         FreeCircularList(tail);
  2535.     }
  2536.     p -> semicolon_token_opt  = 0;
  2537.     Sym(1) = p;
  2538. }
  2539. ./
  2540.  
  2541. --1.1 feature
  2542. LocalVariableDeclaration ::= Modifiers Type VariableDeclarators
  2543. \:$action:\
  2544. /.$location
  2545. void Parser::Act$rule_number(void)
  2546. {
  2547.     AstLocalVariableDeclarationStatement *p = ast_pool -> NewLocalVariableDeclarationStatement();
  2548.     //
  2549.     // The list of modifiers is guaranteed not empty
  2550.     //
  2551.     {   
  2552.         AstListNode *tail = (AstListNode *) Sym(1);
  2553.         p -> AllocateLocalModifiers(tail -> index + 1);
  2554.         AstListNode *root = tail;
  2555.         do
  2556.         {
  2557.             root = root -> next;
  2558.             p -> AddLocalModifier((AstModifier *) root -> element);
  2559.         } while(root != tail);
  2560.         FreeCircularList(tail);
  2561.     }
  2562.     p -> type = Sym(2);
  2563.     //
  2564.     // The list of declarators is guaranteed not empty
  2565.     //
  2566.     {   
  2567.         AstListNode *tail = (AstListNode *) Sym(3);
  2568.         p -> AllocateVariableDeclarators(tail -> index + 1);
  2569.         AstListNode *root = tail;
  2570.         do
  2571.         {
  2572.             root = root -> next;
  2573.             p -> AddVariableDeclarator((AstVariableDeclarator *) root -> element);
  2574.         } while(root != tail);
  2575.         FreeCircularList(tail);
  2576.     }
  2577.     p -> semicolon_token_opt  = 0;
  2578.     Sym(1) = p;
  2579. }
  2580. ./
  2581.  
  2582. Statement -> StatementWithoutTrailingSubstatement
  2583. \:$NoAction:\
  2584. /.$shared_NoAction./
  2585.  
  2586. Statement -> LabeledStatement
  2587. \:$NoAction:\
  2588. /.$shared_NoAction./
  2589.  
  2590. Statement -> IfThenStatement
  2591. \:$NoAction:\
  2592. /.$shared_NoAction./
  2593.  
  2594. Statement -> IfThenElseStatement
  2595. \:$NoAction:\
  2596. /.$shared_NoAction./
  2597.  
  2598. Statement -> WhileStatement
  2599. \:$NoAction:\
  2600. /.$shared_NoAction./
  2601.  
  2602. Statement -> ForStatement
  2603. \:$NoAction:\
  2604. /.$shared_NoAction./
  2605.  
  2606. StatementNoShortIf -> StatementWithoutTrailingSubstatement
  2607. \:$NoAction:\
  2608. /.$shared_NoAction./
  2609.  
  2610. StatementNoShortIf -> LabeledStatementNoShortIf
  2611. \:$NoAction:\
  2612. /.$shared_NoAction./
  2613.  
  2614. StatementNoShortIf -> IfThenElseStatementNoShortIf
  2615. \:$NoAction:\
  2616. /.$shared_NoAction./
  2617.  
  2618. StatementNoShortIf -> WhileStatementNoShortIf
  2619. \:$NoAction:\
  2620. /.$shared_NoAction./
  2621.  
  2622. StatementNoShortIf -> ForStatementNoShortIf
  2623. \:$NoAction:\
  2624. /.$shared_NoAction./
  2625.  
  2626. StatementWithoutTrailingSubstatement -> Block
  2627. \:$NoAction:\
  2628. /.$shared_NoAction./
  2629.  
  2630. StatementWithoutTrailingSubstatement -> EmptyStatement
  2631. \:$NoAction:\
  2632. /.$shared_NoAction./
  2633.  
  2634. StatementWithoutTrailingSubstatement -> ExpressionStatement
  2635. \:$NoAction:\
  2636. /.$shared_NoAction./
  2637.  
  2638. StatementWithoutTrailingSubstatement -> SwitchStatement
  2639. \:$NoAction:\
  2640. /.$shared_NoAction./
  2641.  
  2642. StatementWithoutTrailingSubstatement -> DoStatement
  2643. \:$NoAction:\
  2644. /.$shared_NoAction./
  2645.  
  2646. StatementWithoutTrailingSubstatement -> BreakStatement
  2647. \:$NoAction:\
  2648. /.$shared_NoAction./
  2649.  
  2650. StatementWithoutTrailingSubstatement -> ContinueStatement
  2651. \:$NoAction:\
  2652. /.$shared_NoAction./
  2653.  
  2654. StatementWithoutTrailingSubstatement -> ReturnStatement
  2655. \:$NoAction:\
  2656. /.$shared_NoAction./
  2657.  
  2658. StatementWithoutTrailingSubstatement -> SynchronizedStatement
  2659. \:$NoAction:\
  2660. /.$shared_NoAction./
  2661.  
  2662. StatementWithoutTrailingSubstatement -> ThrowStatement
  2663. \:$NoAction:\
  2664. /.$shared_NoAction./
  2665.  
  2666. StatementWithoutTrailingSubstatement -> TryStatement
  2667. \:$NoAction:\
  2668. /.$shared_NoAction./
  2669.  
  2670. EmptyStatement ::= ';'
  2671. \:$MakeEmptyStatement:\
  2672. /.$shared_function
  2673. //
  2674. // void MakeEmptyStatement(void);
  2675. //./
  2676.  
  2677. LabeledStatement ::= 'Identifier' ':' Statement
  2678. \:$MakeLabeledStatement:\
  2679. /.$location
  2680. void Parser::MakeLabeledStatement(void)
  2681. {
  2682.     AstBlock *p = Sym(3) -> BlockCast();
  2683.  
  2684.     if (! (p && p -> NumStatements() == 1 &&
  2685.            (p -> Statement(0) -> kind == Ast::FOR   ||
  2686.             p -> Statement(0) -> kind == Ast::WHILE ||
  2687.             p -> Statement(0) -> kind == Ast::DO)))
  2688.     {
  2689.         //
  2690.         // When a statement is labeled, it is enclosed in a block.
  2691.         // This is necessary in order to allow the same name to be
  2692.         // reused to label a subsequent statement at the same nesting
  2693.         // level... See ProcessBlock, ProcessStatement,...
  2694.         //
  2695.         p = ast_pool -> NewBlock();
  2696.         p -> AllocateBlockStatements(1); // allocate 1 element
  2697.         p -> left_brace_token  = Token(1);
  2698.         p -> AddStatement((AstStatement *) Sym(3));
  2699.         p -> right_brace_token = Sym(3) -> RightToken();
  2700.     }
  2701.  
  2702.     p -> label_token_opt = Token(1); // add label to statement
  2703.     Sym(1) = p; // The final result is a block containing the labeled-statement
  2704. }
  2705. ./
  2706.  
  2707. LabeledStatementNoShortIf ::= 'Identifier' ':' StatementNoShortIf
  2708. \:$MakeLabeledStatement:\
  2709. /.$shared_function
  2710. //
  2711. // void MakeLabeledStatement(void);
  2712. //./
  2713.  
  2714. ExpressionStatement ::= StatementExpression ';'
  2715. \:$action:\
  2716. /.$location
  2717. void Parser::Act$rule_number(void)
  2718. {
  2719.     ((AstExpressionStatement *) Sym(1)) -> semicolon_token_opt = Token(2);
  2720. }
  2721. ./
  2722.  
  2723. StatementExpression ::= Assignment
  2724. \:$MakeExpressionStatement:\
  2725. /.$location
  2726. void Parser::MakeExpressionStatement(void)
  2727. {
  2728.     AstExpressionStatement *p = ast_pool -> NewExpressionStatement();
  2729.     p -> expression          = (AstExpression *) Sym(1);
  2730.     p -> semicolon_token_opt = 0;
  2731.     Sym(1) = p;
  2732. }
  2733. ./
  2734.  
  2735. StatementExpression ::= PreIncrementExpression
  2736. \:$MakeExpressionStatement:\
  2737. /.$shared_function
  2738. //
  2739. // void MakeExpressionStatement(void);
  2740. //./
  2741.  
  2742. StatementExpression ::= PreDecrementExpression
  2743. \:$MakeExpressionStatement:\
  2744. /.$shared_function
  2745. //
  2746. // void MakeExpressionStatement(void);
  2747. //./
  2748.  
  2749. StatementExpression ::= PostIncrementExpression
  2750. \:$MakeExpressionStatement:\
  2751. /.$shared_function
  2752. //
  2753. // void MakeExpressionStatement(void);
  2754. //./
  2755.  
  2756. StatementExpression ::= PostDecrementExpression
  2757. \:$MakeExpressionStatement:\
  2758. /.$shared_function
  2759. //
  2760. // void MakeExpressionStatement(void);
  2761. //./
  2762.  
  2763. StatementExpression ::= MethodInvocation
  2764. \:$MakeExpressionStatement:\
  2765. /.$shared_function
  2766. //
  2767. // void MakeExpressionStatement(void);
  2768. //./
  2769.  
  2770. StatementExpression ::= ClassInstanceCreationExpression
  2771. \:$MakeExpressionStatement:\
  2772. /.$shared_function
  2773. //
  2774. // void MakeExpressionStatement(void);
  2775. //./
  2776.  
  2777. IfThenStatement ::=  'if' '(' Expression ')' Statement
  2778. \:$action:\
  2779. /.$location
  2780. void Parser::Act$rule_number(void)
  2781. {
  2782.     AstBlock *block = Sym(5) -> BlockCast();
  2783.     if (! block)
  2784.     {
  2785.         block = ast_pool -> NewBlock();
  2786.         block -> AllocateBlockStatements(1); // allocate 1 element
  2787.         block -> left_brace_token  = Token(5);
  2788.         block -> AddStatement((AstStatement *) Sym(5));
  2789.         block -> right_brace_token = Sym(5) -> RightToken();
  2790.     }
  2791.  
  2792.     AstIfStatement *p = ast_pool -> NewIfStatement();
  2793.     p -> if_token            = Token(1);
  2794.     p -> expression          = (AstExpression *) Sym(3);
  2795.     p -> true_statement      = block;
  2796.     p -> false_statement_opt = NULL;
  2797.     Sym(1) = p;
  2798. }
  2799. ./
  2800.  
  2801. IfThenElseStatement ::=  'if' '(' Expression ')' StatementNoShortIf 'else' Statement
  2802. \:$MakeIfThenElseStatement:\
  2803. /.$location
  2804. void Parser::MakeIfThenElseStatement(void)
  2805. {
  2806.     AstBlock *true_block = Sym(5) -> BlockCast();
  2807.     if (! true_block)
  2808.     {
  2809.         true_block = ast_pool -> NewBlock();
  2810.         true_block -> AllocateBlockStatements(1); // allocate 1 element
  2811.         true_block -> left_brace_token  = Token(5);
  2812.         true_block -> AddStatement((AstStatement *) Sym(5));
  2813.         true_block -> right_brace_token = Sym(5) -> RightToken();
  2814.     }
  2815.  
  2816.     AstBlock *false_block = Sym(7) -> BlockCast();
  2817.     if (! false_block)
  2818.     {
  2819.         false_block = ast_pool -> NewBlock();
  2820.         false_block -> AllocateBlockStatements(1); // allocate 1 element
  2821.         false_block -> left_brace_token  = Token(7);
  2822.         false_block -> AddStatement((AstStatement *) Sym(7));
  2823.         false_block -> right_brace_token = Sym(7) -> RightToken();
  2824.     }
  2825.  
  2826.     AstIfStatement *p = ast_pool -> NewIfStatement();
  2827.     p -> if_token            = Token(1);
  2828.     p -> expression          = (AstExpression *) Sym(3);
  2829.     p -> true_statement      = true_block;
  2830.     p -> false_statement_opt = false_block;
  2831.     Sym(1) = p;
  2832. }
  2833. ./
  2834.  
  2835. IfThenElseStatementNoShortIf ::=  'if' '(' Expression ')' StatementNoShortIf 'else' StatementNoShortIf
  2836. \:$MakeIfThenElseStatement:\
  2837. /.$shared_function
  2838. //
  2839. // void MakeIfThenElseStatement(void);
  2840. //./
  2841.  
  2842. SwitchStatement ::= 'switch' '(' Expression ')' SwitchBlock
  2843. \:$action:\
  2844. /.$location
  2845. void Parser::Act$rule_number(void)
  2846. {
  2847.     AstSwitchStatement *p = (AstSwitchStatement *) Sym(5);
  2848.     p -> switch_token = Token(1);
  2849.     p -> expression   = (AstExpression *) Sym(3);
  2850.     Sym(1) = p;
  2851. }
  2852. ./
  2853.  
  2854. SwitchBlock ::= '{' '}'
  2855. \:$action:\
  2856. /.$location
  2857. void Parser::Act$rule_number(void)
  2858. {
  2859.     AstSwitchStatement *p = ast_pool -> NewSwitchStatement();
  2860.  
  2861.     AstBlock *block = ast_pool -> NewBlock();
  2862.     block -> left_brace_token  = Token(1);
  2863.     block -> right_brace_token = Token(2);
  2864.  
  2865.     p -> switch_block = block;
  2866.  
  2867.     Sym(1) = p;
  2868. }
  2869. ./
  2870.  
  2871. SwitchBlock ::= '{' SwitchBlockStatements '}'
  2872. \:$action:\
  2873. /.$location
  2874. void Parser::Act$rule_number(void)
  2875. {
  2876.     AstSwitchStatement *p = ast_pool -> NewSwitchStatement();
  2877.  
  2878.     AstBlock *block = ast_pool -> NewBlock();
  2879.     block -> left_brace_token  = Token(1);
  2880.     if (Sym(2) != NULL)
  2881.     {
  2882.         AstListNode *tail = (AstListNode *) Sym(2);
  2883.         block -> AllocateBlockStatements(tail -> index + 1);
  2884.         AstListNode *root = tail;
  2885.         do
  2886.         {
  2887.             root = root -> next;
  2888.             block -> AddStatement((AstStatement *) root -> element);
  2889.         } while(root != tail);
  2890.         FreeCircularList(tail);
  2891.     }
  2892.     block -> right_brace_token = Token(3);
  2893.  
  2894.     p -> switch_block  = block;
  2895.  
  2896.     Sym(1) = p;
  2897. }
  2898. ./
  2899.  
  2900. SwitchBlock ::= '{' SwitchLabels '}'
  2901. \:$action:\
  2902. /.$location
  2903. void Parser::Act$rule_number(void)
  2904. {
  2905.     AstSwitchStatement *p = ast_pool -> NewSwitchStatement();
  2906.  
  2907.     AstSwitchBlockStatement *q = ast_pool -> NewSwitchBlockStatement();
  2908.     //
  2909.     // The list of SwitchBlockStatements is never null
  2910.     //
  2911.     {
  2912.         AstListNode *tail = (AstListNode *) Sym(2);
  2913.         q -> AllocateSwitchLabels(tail -> index + 1);
  2914.         AstListNode *root = tail;
  2915.         do
  2916.         {
  2917.             root = root -> next;
  2918.             q -> AddSwitchLabel((AstStatement *) root -> element);
  2919.         } while(root != tail);
  2920.         FreeCircularList(tail);
  2921.     }
  2922.  
  2923.     AstBlock *block = ast_pool -> NewBlock();
  2924.     block -> AllocateBlockStatements(1); // allocate 1 element
  2925.     block -> left_brace_token  = Token(1);
  2926.     block -> AddStatement(q);
  2927.     block -> right_brace_token = Token(3);
  2928.  
  2929.     p -> switch_block  = block;
  2930.  
  2931.     Sym(1) = p;
  2932. }
  2933. ./
  2934.  
  2935. SwitchBlock ::= '{' SwitchBlockStatements SwitchLabels '}'
  2936. \:$action:\
  2937. /.$location
  2938. void Parser::Act$rule_number(void)
  2939. {
  2940.     AstSwitchStatement *p = ast_pool -> NewSwitchStatement();
  2941.  
  2942.     AstBlock *block = ast_pool -> NewBlock();
  2943.     block -> left_brace_token  = Token(1);
  2944.     //
  2945.     // The list of SwitchBlockStatements is never null
  2946.     //
  2947.     {
  2948.         AstListNode *tail = (AstListNode *) Sym(2);
  2949.         block -> AllocateBlockStatements(tail -> index + 2); // +1 because of extra statement for additional SwithLabels
  2950.         AstListNode *root = tail;
  2951.         do
  2952.         {
  2953.             root = root -> next;
  2954.             block -> AddStatement((AstStatement *) root -> element);
  2955.         } while(root != tail);
  2956.         FreeCircularList(tail);
  2957.     }
  2958.  
  2959.     AstSwitchBlockStatement *q = ast_pool -> NewSwitchBlockStatement();
  2960.     //
  2961.     // The list of SwitchLabels is never null
  2962.     //
  2963.     {
  2964.         AstListNode *tail = (AstListNode *) Sym(3);
  2965.         q -> AllocateSwitchLabels(tail -> index + 1);
  2966.         AstListNode *root = tail;
  2967.         do
  2968.         {
  2969.             root = root -> next;
  2970.             q -> AddSwitchLabel(root -> element);
  2971.         } while(root != tail);
  2972.         FreeCircularList(tail);
  2973.     }
  2974.  
  2975.     block -> AddStatement(q);
  2976.     block -> right_brace_token = Token(4);
  2977.  
  2978.     p -> switch_block  = block;
  2979.  
  2980.     Sym(1) = p;
  2981. }
  2982. ./
  2983.  
  2984. SwitchBlockStatements ::= SwitchBlockStatement
  2985. \:$action:\
  2986. /.$location
  2987. //
  2988. // Note that the list is circular so as to preserve the order of the elements
  2989. //
  2990. void Parser::Act$rule_number(void)
  2991. {
  2992.     AstListNode *p = AllocateListNode();
  2993.     p -> next = p;
  2994.     p -> element = Sym(1);
  2995.     p -> index = 0;
  2996.  
  2997.     Sym(1) = p;
  2998. }
  2999. ./
  3000.  
  3001. SwitchBlockStatements ::= SwitchBlockStatements SwitchBlockStatement
  3002. \:$action:\
  3003. /.$location
  3004. //
  3005. // Note that the list is circular so as to preserve the order of the elements
  3006. //
  3007. void Parser::Act$rule_number(void)
  3008. {
  3009.     AstListNode *tail = (AstListNode *) Sym(1);
  3010.  
  3011.     AstListNode *p = AllocateListNode();
  3012.     p -> element = Sym(2);
  3013.     p -> index = tail -> index + 1;
  3014.  
  3015.     p -> next = tail -> next;
  3016.     tail -> next = p;
  3017.  
  3018.     Sym(1) = p;
  3019. }
  3020. ./
  3021.  
  3022. SwitchBlockStatement ::= SwitchLabels BlockStatements
  3023. \:$action:\
  3024. /.$location
  3025. void Parser::Act$rule_number(void)
  3026. {
  3027.     AstSwitchBlockStatement *p = ast_pool -> NewSwitchBlockStatement();
  3028.     //
  3029.     // The list of SwitchLabels is never null
  3030.     //
  3031.     {
  3032.         AstListNode *tail = (AstListNode *) Sym(1);
  3033.         p -> AllocateSwitchLabels(tail -> index + 1);
  3034.         AstListNode *root = tail;
  3035.         do
  3036.         {
  3037.             root = root -> next;
  3038.             p -> AddSwitchLabel(root -> element);
  3039.         } while(root != tail);
  3040.         FreeCircularList(tail);
  3041.     }
  3042.  
  3043.     //
  3044.     // The list of SwitchBlockStatements is never null
  3045.     //
  3046.     {
  3047.         AstListNode *tail = (AstListNode *) Sym(2);
  3048.         p -> AllocateBlockStatements(tail -> index + 1);
  3049.         AstListNode *root = tail;
  3050.         do
  3051.         {
  3052.             root = root -> next;
  3053.             p -> AddStatement((AstStatement *) root -> element);
  3054.         } while(root != tail);
  3055.         FreeCircularList(tail);
  3056.     }
  3057.     Sym(1) = p;
  3058. }
  3059. ./
  3060.  
  3061. SwitchLabels ::= SwitchLabel
  3062. \:$action:\
  3063. /.$location
  3064. //
  3065. // Note that the list is circular so as to preserve the order of the elements
  3066. //
  3067. void Parser::Act$rule_number(void)
  3068. {
  3069.     AstListNode *p = AllocateListNode();
  3070.     p -> next = p;
  3071.     p -> element = Sym(1);
  3072.     p -> index = 0;
  3073.  
  3074.     Sym(1) = p;
  3075. }
  3076. ./
  3077.  
  3078. SwitchLabels ::= SwitchLabels SwitchLabel
  3079. \:$action:\
  3080. /.$location
  3081. //
  3082. // Note that the list is circular so as to preserve the order of the elements
  3083. //
  3084. void Parser::Act$rule_number(void)
  3085. {
  3086.     AstListNode *tail = (AstListNode *) Sym(1);
  3087.  
  3088.     AstListNode *p = AllocateListNode();
  3089.     p -> element = Sym(2);
  3090.     p -> index = tail -> index + 1;
  3091.  
  3092.     p -> next = tail -> next;
  3093.     tail -> next = p;
  3094.  
  3095.     Sym(1) = p;
  3096. }
  3097. ./
  3098.  
  3099. SwitchLabel ::= 'case' ConstantExpression ':'
  3100. \:$action:\
  3101. /.$location
  3102. void Parser::Act$rule_number(void)
  3103. {
  3104.     AstCaseLabel *p = ast_pool -> NewCaseLabel();
  3105.     p -> case_token  = Token(1);
  3106.     p -> expression  = (AstExpression *) Sym(2);
  3107.     p -> colon_token = Token(3);
  3108.     Sym(1) = p;
  3109. }
  3110. ./
  3111.  
  3112. SwitchLabel ::= 'default' ':'
  3113. \:$action:\
  3114. /.$location
  3115. void Parser::Act$rule_number(void)
  3116. {
  3117.     AstDefaultLabel *p = ast_pool -> NewDefaultLabel();
  3118.     p -> default_token = Token(1);
  3119.     p -> colon_token   = Token(2);
  3120.     Sym(1) = p;
  3121. }
  3122. ./
  3123.  
  3124. WhileStatement ::= 'while' '(' Expression ')' Statement
  3125. \:$MakeWhileStatement:\
  3126. /.$location
  3127. void Parser::MakeWhileStatement(void)
  3128. {
  3129.     AstWhileStatement *p = ast_pool -> NewWhileStatement();
  3130.     p -> while_token = Token(1);
  3131.     p -> expression  = (AstExpression *) Sym(3);
  3132.     p -> statement   = (AstStatement *) Sym(5);
  3133.  
  3134.     AstBlock *block = ast_pool -> NewBlock();
  3135.     block -> AllocateBlockStatements(1); // allocate 1 element
  3136.     block -> left_brace_token  = Token(1); // point to 'FOR' keyword
  3137.     block -> AddStatement(p);
  3138.     block -> right_brace_token = Sym(5) -> RightToken(); // point to last token in statement
  3139.  
  3140.     Sym(1) = block;
  3141. }
  3142. ./
  3143.  
  3144. WhileStatementNoShortIf ::= 'while' '(' Expression ')' StatementNoShortIf
  3145. \:$MakeWhileStatement:\
  3146. /.$shared_function
  3147. //
  3148. // void MakeWhileStatement(void);
  3149. //./
  3150.  
  3151. DoStatement ::= 'do' Statement 'while' '(' Expression ')' ';'
  3152. \:$action:\
  3153. /.$location
  3154. void Parser::Act$rule_number(void)
  3155. {
  3156.     AstDoStatement *p = ast_pool -> NewDoStatement();
  3157.     p -> do_token        = Token(1);
  3158.     p -> statement       = (AstStatement *) Sym(2);
  3159.     p -> while_token     = Token(3);
  3160.     p -> expression      = (AstExpression *) Sym(5);
  3161.     p -> semicolon_token = Token(7);
  3162.  
  3163.     AstBlock *block = ast_pool -> NewBlock();
  3164.     block -> AllocateBlockStatements(1); // allocate 1 element
  3165.     block -> left_brace_token  = Token(1);
  3166.     block -> AddStatement(p);
  3167.     block -> right_brace_token = Token(7);
  3168.  
  3169.     Sym(1) = block;
  3170. }
  3171. ./
  3172.  
  3173. ForStatement ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' Statement
  3174. \:$MakeForStatement:\
  3175. /.$location
  3176. void Parser::MakeForStatement(void)
  3177. {
  3178.     AstForStatement *p = ast_pool -> NewForStatement();
  3179.     p -> for_token = Token(1);
  3180.     if (Sym(3) != NULL)
  3181.     {
  3182.         AstListNode *tail = (AstListNode *) Sym(3);
  3183.         p -> AllocateForInitStatements(tail -> index + 1);
  3184.         AstListNode *root = tail;
  3185.         do
  3186.         {
  3187.             root = root -> next;
  3188.             p -> AddForInitStatement((AstStatement *) root -> element);
  3189.         } while(root != tail);
  3190.         FreeCircularList(tail);
  3191.     }
  3192.     p -> end_expression_opt = (AstExpression *) Sym(5);
  3193.     if (Sym(7) != NULL)
  3194.     {
  3195.         AstListNode *tail = (AstListNode *) Sym(7);
  3196.         p -> AllocateForUpdateStatements(tail -> index + 1);
  3197.         AstListNode *root = tail;
  3198.         do
  3199.         {
  3200.             root = root -> next;
  3201.             p -> AddForUpdateStatement((AstExpressionStatement *) root -> element);
  3202.         } while(root != tail);
  3203.         FreeCircularList(tail);
  3204.     }
  3205.     p -> statement = (AstStatement *) Sym(9);
  3206.  
  3207.     AstBlock *block = ast_pool -> NewBlock();
  3208.     block -> AllocateBlockStatements(1); // allocate 1 element
  3209.     block -> left_brace_token  = Token(1);
  3210.     block -> AddStatement(p);
  3211.     block -> right_brace_token = Sym(9) -> RightToken();
  3212.  
  3213.     Sym(1) = block;
  3214. }
  3215. ./
  3216.  
  3217. ForStatementNoShortIf ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' StatementNoShortIf
  3218. \:$MakeForStatement:\
  3219. /.$shared_function
  3220. //
  3221. // void MakeForStatement(void);
  3222. //./
  3223.  
  3224. ForInit -> StatementExpressionList
  3225. \:$NoAction:\
  3226. /.$shared_NoAction./
  3227.  
  3228. ForInit ::= LocalVariableDeclaration
  3229. \:$action:\
  3230. /.$location
  3231. //
  3232. // Note that the list is circular so as to preserve the order of the elements
  3233. //
  3234. void Parser::Act$rule_number(void)
  3235. {
  3236.     AstListNode *p = AllocateListNode();
  3237.     p -> next = p;
  3238.     p -> element = Sym(1);
  3239.     p -> index = 0;
  3240.  
  3241.     Sym(1) = p;
  3242. }
  3243. ./
  3244.  
  3245. ForUpdate -> StatementExpressionList
  3246. \:$NoAction:\
  3247. /.$shared_NoAction./
  3248.  
  3249. StatementExpressionList ::= StatementExpression
  3250. \:$action:\
  3251. /.$location
  3252. //
  3253. // Note that the list is circular so as to preserve the order of the elements
  3254. //
  3255. void Parser::Act$rule_number(void)
  3256. {
  3257.     AstListNode *p = AllocateListNode();
  3258.     p -> next = p;
  3259.     p -> element = Sym(1);
  3260.     p -> index = 0;
  3261.  
  3262.     Sym(1) = p;
  3263. }
  3264. ./
  3265.  
  3266. StatementExpressionList ::= StatementExpressionList ',' StatementExpression
  3267. \:$action:\
  3268. /.$location
  3269. //
  3270. // Note that the list is circular so as to preserve the order of the elements
  3271. //
  3272. void Parser::Act$rule_number(void)
  3273. {
  3274.     AstListNode *tail = (AstListNode *) Sym(1);
  3275.  
  3276.     AstListNode *p = AllocateListNode();
  3277.     p -> element = Sym(3);
  3278.     p -> index = tail -> index + 1;
  3279.  
  3280.     p -> next = tail -> next;
  3281.     tail -> next = p;
  3282.  
  3283.     Sym(1) = p;
  3284. }
  3285. ./
  3286.  
  3287. --
  3288. -- NOTE that the rule Identifieropt was expanded in line in the two
  3289. -- contexts where it appeared: Break and Continue statements.
  3290. -- This was done because there is no straightforward way of passing
  3291. -- optional token information in the parse stack.
  3292. --
  3293. BreakStatement ::= 'break' ';'
  3294. \:$action:\
  3295. /.$location
  3296. void Parser::Act$rule_number(void)
  3297. {
  3298.     AstBreakStatement *p = ast_pool -> NewBreakStatement();
  3299.     p -> break_token          = Token(1);
  3300.     p -> identifier_token_opt = 0;
  3301.     p -> semicolon_token      = Token(2);
  3302.     Sym(1) = p;
  3303. }
  3304. ./
  3305.  
  3306. BreakStatement ::= 'break' 'Identifier' ';'
  3307. \:$action:\
  3308. /.$location
  3309. void Parser::Act$rule_number(void)
  3310. {
  3311.     AstBreakStatement *p = ast_pool -> NewBreakStatement();
  3312.     p -> break_token          = Token(1);
  3313.     p -> identifier_token_opt = Token(2);
  3314.     p -> semicolon_token      = Token(3);
  3315.     Sym(1) = p;
  3316. }
  3317. ./
  3318.  
  3319. ContinueStatement ::= 'continue' ';'
  3320. \:$action:\
  3321. /.$location
  3322. void Parser::Act$rule_number(void)
  3323. {
  3324.     AstContinueStatement *p = ast_pool -> NewContinueStatement();
  3325.     p -> continue_token       = Token(1);
  3326.     p -> identifier_token_opt = 0;
  3327.     p -> semicolon_token      = Token(2);
  3328.     Sym(1) = p;
  3329. }
  3330. ./
  3331.  
  3332. ContinueStatement ::= 'continue' 'Identifier' ';'
  3333. \:$action:\
  3334. /.$location
  3335. void Parser::Act$rule_number(void)
  3336. {
  3337.     AstContinueStatement *p = ast_pool -> NewContinueStatement();
  3338.     p -> continue_token       = Token(1);
  3339.     p -> identifier_token_opt = Token(2);
  3340.     p -> semicolon_token      = Token(3);
  3341.     Sym(1) = p;
  3342. }
  3343. ./
  3344.  
  3345. ReturnStatement ::= 'return' Expressionopt ';'
  3346. \:$action:\
  3347. /.$location
  3348. void Parser::Act$rule_number(void)
  3349. {
  3350.     AstReturnStatement *p = ast_pool -> NewReturnStatement();
  3351.     p -> return_token    = Token(1);
  3352.     p -> expression_opt  = (AstExpression *) Sym(2);
  3353.     p -> semicolon_token = Token(3);
  3354.     Sym(1) = p;
  3355. }
  3356. ./
  3357.  
  3358. ThrowStatement ::= 'throw' Expression ';'
  3359. \:$action:\
  3360. /.$location
  3361. void Parser::Act$rule_number(void)
  3362. {
  3363.     AstThrowStatement *p = ast_pool -> NewThrowStatement();
  3364.     p -> throw_token     = Token(1);
  3365.     p -> expression      = (AstExpression *) Sym(2);
  3366.     p -> semicolon_token = Token(3);
  3367.     Sym(1) = p;
  3368. }
  3369. ./
  3370.  
  3371. SynchronizedStatement ::= 'synchronized' '(' Expression ')' Block
  3372. \:$action:\
  3373. /.$location
  3374. void Parser::Act$rule_number(void)
  3375. {
  3376.     AstSynchronizedStatement *p = ast_pool -> NewSynchronizedStatement();
  3377.     p -> synchronized_token = Token(1);
  3378.     p -> expression         = (AstExpression *) Sym(3);
  3379.     p -> block              = (AstBlock *) Sym(5);
  3380.     Sym(1) = p;
  3381. }
  3382. ./
  3383.  
  3384. TryStatement ::= 'try' Block Catches
  3385. \:$action:\
  3386. /.$location
  3387. void Parser::Act$rule_number(void)
  3388. {
  3389.     AstTryStatement *p = ast_pool -> NewTryStatement();
  3390.     p -> try_token          = Token(1);
  3391.     p -> block              = (AstBlock *) Sym(2);
  3392.     //
  3393.     // The list of modifiers is guaranteed not empty
  3394.     //
  3395.     {
  3396.         AstListNode *tail = (AstListNode *) Sym(3);
  3397.         p -> AllocateCatchClauses(tail -> index + 1);
  3398.         AstListNode *root = tail;
  3399.         do
  3400.         {
  3401.             root = root -> next;
  3402.             p -> AddCatchClause((AstCatchClause *) root -> element);
  3403.         } while(root != tail);
  3404.         FreeCircularList(tail);
  3405.     }
  3406.     p -> finally_clause_opt = NULL;
  3407.     Sym(1) = p;
  3408. }
  3409. ./
  3410.  
  3411. TryStatement ::= 'try' Block Catchesopt Finally
  3412. \:$action:\
  3413. /.$location
  3414. void Parser::Act$rule_number(void)
  3415. {
  3416.     AstTryStatement *p = ast_pool -> NewTryStatement();
  3417.     p -> try_token      = Token(1);
  3418.     p -> block          = (AstBlock *) Sym(2);
  3419.     if (Sym(3) != NULL)
  3420.     {
  3421.         AstListNode *tail = (AstListNode *) Sym(3);
  3422.         p -> AllocateCatchClauses(tail -> index + 1);
  3423.         AstListNode *root = tail;
  3424.         do
  3425.         {
  3426.             root = root -> next;
  3427.             p -> AddCatchClause((AstCatchClause *) root -> element);
  3428.         } while(root != tail);
  3429.         FreeCircularList(tail);
  3430.     }
  3431.     p -> finally_clause_opt = (AstFinallyClause *) Sym(4);
  3432.     Sym(1) = p;
  3433. }
  3434. ./
  3435.  
  3436. Catches ::= CatchClause
  3437. \:$action:\
  3438. /.$location
  3439. //
  3440. // Note that the list is circular so as to preserve the order of the elements
  3441. //
  3442. void Parser::Act$rule_number(void)
  3443. {
  3444.     AstListNode *p = AllocateListNode();
  3445.     p -> next = p;
  3446.     p -> element = Sym(1);
  3447.     p -> index = 0;
  3448.  
  3449.     Sym(1) = p;
  3450. }
  3451. ./
  3452.  
  3453. Catches ::= Catches CatchClause
  3454. \:$action:\
  3455. /.$location
  3456. //
  3457. // Note that the list is circular so as to preserve the order of the elements
  3458. //
  3459. void Parser::Act$rule_number(void)
  3460. {
  3461.     AstListNode *tail = (AstListNode *) Sym(1);
  3462.  
  3463.     AstListNode *p = AllocateListNode();
  3464.     p -> element = Sym(2);
  3465.     p -> index = tail -> index + 1;
  3466.  
  3467.     p -> next = tail -> next;
  3468.     tail -> next = p;
  3469.  
  3470.     Sym(1) = p;
  3471. }
  3472. ./
  3473.  
  3474. CatchClause ::= 'catch' '(' FormalParameter ')' Block
  3475. \:$action:\
  3476. /.$location
  3477. void Parser::Act$rule_number(void)
  3478. {
  3479.     AstCatchClause *p = ast_pool -> NewCatchClause();
  3480.     p -> catch_token      = Token(1);
  3481.     p -> formal_parameter = (AstFormalParameter *) Sym(3);
  3482.     p -> block            = (AstBlock *) Sym(5);
  3483.     Sym(1) = p;
  3484. }
  3485. ./
  3486.  
  3487. Finally ::= 'finally' Block
  3488. \:$action:\
  3489. /.$location
  3490. void Parser::Act$rule_number(void)
  3491. {
  3492.     AstFinallyClause *p = ast_pool -> NewFinallyClause();
  3493.     p -> finally_token = Token(1);
  3494.     p -> block         = (AstBlock *) Sym(2);
  3495.     Sym(1) = p;
  3496. }
  3497. ./
  3498.  
  3499. --18.12 Productions from 14: Expressions
  3500.  
  3501. Primary -> PrimaryNoNewArray
  3502. \:$NoAction:\
  3503. /.$shared_NoAction./
  3504.  
  3505. Primary -> ArrayCreationExpression
  3506. \:$NoAction:\
  3507. /.$shared_NoAction./
  3508.  
  3509. PrimaryNoNewArray -> Literal
  3510. \:$NoAction:\
  3511. /.$shared_NoAction./
  3512.  
  3513. PrimaryNoNewArray ::= this
  3514. \:$action:\
  3515. /.$location
  3516. void Parser::Act$rule_number(void)
  3517. {
  3518.     Sym(1) = ast_pool -> NewThisExpression(Token(1));
  3519. }
  3520. ./
  3521.  
  3522. PrimaryNoNewArray ::= '(' Expression ')'
  3523. \:$action:\
  3524. /.$location
  3525. void Parser::Act$rule_number(void)
  3526. {
  3527.     AstParenthesizedExpression *p = ast_pool -> NewParenthesizedExpression();
  3528.     p -> left_parenthesis_token = Token(1);
  3529.     p -> expression = (AstExpression *) Sym(2);
  3530.     p -> right_parenthesis_token = Token(3);
  3531.     Sym(1) = p;
  3532. }
  3533. ./
  3534.  
  3535. PrimaryNoNewArray -> ClassInstanceCreationExpression
  3536. \:$NoAction:\
  3537. /.$shared_NoAction./
  3538.  
  3539. PrimaryNoNewArray -> FieldAccess
  3540. \:$NoAction:\
  3541. /.$shared_NoAction./
  3542.  
  3543. --1.1 feature
  3544. PrimaryNoNewArray ::= Name '.' 'this'
  3545. \:$action:\
  3546. /.$location
  3547. void Parser::Act$rule_number(void)
  3548. {
  3549.     AstFieldAccess *p = ast_pool -> NewFieldAccess(AstFieldAccess::THIS_TAG);
  3550.     p -> base = (AstExpression *) Sym(1);
  3551.     p -> dot_token = Token(2);
  3552.     p -> identifier_token = Token(3);
  3553.     Sym(1) = p;
  3554. }
  3555. ./
  3556.  
  3557. --1.1 feature
  3558. PrimaryNoNewArray ::= Type '.' 'class'
  3559. \:$action:\
  3560. /.$location
  3561. void Parser::Act$rule_number(void)
  3562. {
  3563.     AstFieldAccess *p = ast_pool -> NewFieldAccess(AstFieldAccess::CLASS_TAG);
  3564.     p -> base = ast_pool -> NewTypeExpression(Sym(1));
  3565.     p -> dot_token = Token(2);
  3566.     p -> identifier_token = Token(3);
  3567.     Sym(1) = p;
  3568. }
  3569. ./
  3570.  
  3571. --1.1 feature
  3572. PrimaryNoNewArray ::= 'void' '.' 'class'
  3573. \:$action:\
  3574. /.$location
  3575. void Parser::Act$rule_number(void)
  3576. {
  3577.     AstFieldAccess *p = ast_pool -> NewFieldAccess(AstFieldAccess::CLASS_TAG);
  3578.     p -> base = ast_pool -> NewTypeExpression(ast_pool -> NewPrimitiveType(Ast::VOID_TYPE, Token(1)));
  3579.     p -> dot_token = Token(2);
  3580.     p -> identifier_token = Token(3);
  3581.     Sym(1) = p;
  3582. }
  3583. ./
  3584.  
  3585. PrimaryNoNewArray -> MethodInvocation
  3586. \:$NoAction:\
  3587. /.$shared_NoAction./
  3588.  
  3589. PrimaryNoNewArray -> ArrayAccess
  3590. \:$NoAction:\
  3591. /.$shared_NoAction./
  3592.  
  3593. --1.1 feature
  3594. --
  3595. -- In Java 1.0 a ClassBody could not appear at all in a
  3596. -- ClassInstanceCreationExpression.
  3597. --
  3598. ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt
  3599. \:$action:\
  3600. /.$location
  3601. void Parser::Act$rule_number(void)
  3602. {
  3603.     AstClassInstanceCreationExpression *p = ast_pool -> NewClassInstanceCreationExpression();
  3604.     p -> base_opt                = NULL;
  3605.     p -> dot_token_opt           = 0;
  3606.     p -> new_token               = Token(1);
  3607.     p -> class_type              = ast_pool -> NewTypeExpression(Sym(2));
  3608.     p -> left_parenthesis_token  = Token(3);
  3609.     if (Sym(4) != NULL)
  3610.     {
  3611.         AstListNode *tail = (AstListNode *) Sym(4);
  3612.         p -> AllocateArguments(tail -> index + 1);
  3613.         AstListNode *root = tail;
  3614.         do
  3615.         {
  3616.             root = root -> next;
  3617.             p -> AddArgument((AstExpression *) root -> element);
  3618.         } while(root != tail);
  3619.         FreeCircularList(tail);
  3620.     }
  3621.     p -> right_parenthesis_token = Token(5);
  3622.     p -> class_body_opt          = (AstClassBody *) Sym(6);
  3623.     Sym(1) = p;
  3624. }
  3625. ./
  3626.  
  3627. --1.1 feature
  3628. ClassInstanceCreationExpression ::= Primary '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
  3629. \:$MakeQualifiedNew:\
  3630. /.$location
  3631. void Parser::MakeQualifiedNew(void)
  3632. {
  3633.     AstClassInstanceCreationExpression *p = ast_pool -> NewClassInstanceCreationExpression();
  3634.     p -> base_opt                = (AstExpression *) Sym(1);
  3635.     p -> dot_token_opt           = Token(2);
  3636.     p -> new_token               = Token(3);
  3637.     p -> class_type              = ast_pool -> NewTypeExpression(Sym(4));
  3638.     p -> left_parenthesis_token  = Token(5);
  3639.     if (Sym(6) != NULL)
  3640.     {
  3641.         AstListNode *tail = (AstListNode *) Sym(6);
  3642.         p -> AllocateArguments(tail -> index + 1);
  3643.         AstListNode *root = tail;
  3644.         do
  3645.         {
  3646.             root = root -> next;
  3647.             p -> AddArgument((AstExpression *) root -> element);
  3648.         } while(root != tail);
  3649.         FreeCircularList(tail);
  3650.     }
  3651.     p -> right_parenthesis_token = Token(7);
  3652.     p -> class_body_opt          = (AstClassBody *) Sym(8);
  3653.     Sym(1) = p;
  3654. }
  3655. ./
  3656.  
  3657. --1.1 feature
  3658. ClassInstanceCreationExpression ::= Name '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
  3659. \:$MakeQualifiedNew:\
  3660. /.$shared_function
  3661. //
  3662. // void MakeQualifiedNew(void);
  3663. //./
  3664.  
  3665. ArgumentList ::= Expression
  3666. \:$action:\
  3667. /.$location
  3668. //
  3669. // Note that the list is circular so as to preserve the order of the elements
  3670. //
  3671. void Parser::Act$rule_number(void)
  3672. {
  3673.     AstListNode *p = AllocateListNode();
  3674.     p -> next = p;
  3675.     p -> element = Sym(1);
  3676.     p -> index = 0;
  3677.  
  3678.     Sym(1) = p;
  3679. }
  3680. ./
  3681.  
  3682. ArgumentList ::= ArgumentList ',' Expression
  3683. \:$action:\
  3684. /.$location
  3685. //
  3686. // Note that the list is circular so as to preserve the order of the elements
  3687. //
  3688. void Parser::Act$rule_number(void)
  3689. {
  3690.     AstListNode *tail = (AstListNode *) Sym(1);
  3691.  
  3692.     AstListNode *p = AllocateListNode();
  3693.     p -> element = Sym(3);
  3694.     p -> index = tail -> index + 1;
  3695.  
  3696.     p -> next = tail -> next;
  3697.     tail -> next = p;
  3698.  
  3699.     Sym(1) = p;
  3700. }
  3701. ./
  3702.  
  3703. ArrayCreationExpression ::= 'new' PrimitiveType DimExprs Dimsopt
  3704. \:$MakeArrayCreationExpression:\
  3705. /.$location
  3706. void Parser::MakeArrayCreationExpression(void)
  3707. {
  3708.     AstArrayCreationExpression *p = ast_pool -> NewArrayCreationExpression();
  3709.     p -> new_token             = Token(1);
  3710.     p -> array_type            = Sym(2);
  3711.     //
  3712.     // The list of DimExprs is never null
  3713.     //
  3714.     {
  3715.         AstListNode *tail = (AstListNode *) Sym(3);
  3716.         p -> AllocateDimExprs(tail -> index + 1);
  3717.         AstListNode *root = tail;
  3718.         do
  3719.         {
  3720.             root = root -> next;
  3721.             p -> AddDimExpr((AstDimExpr *) root -> element);
  3722.         } while(root != tail);
  3723.         FreeCircularList(tail);
  3724.     }
  3725.  
  3726.     if (Sym(4) != NULL)
  3727.     {
  3728.         AstListNode *tail = (AstListNode *) Sym(4);
  3729.         p -> AllocateBrackets(tail -> index + 1);
  3730.         AstListNode *root = tail;
  3731.         do
  3732.         {
  3733.             root = root -> next;
  3734.             p -> AddBrackets((AstBrackets *) root -> element);
  3735.         } while(root != tail);
  3736.         FreeCircularList(tail);
  3737.     }
  3738.     p -> array_initializer_opt = NULL;
  3739.     Sym(1) = p;
  3740. }
  3741. ./
  3742.  
  3743. ArrayCreationExpression ::= 'new' ClassOrInterfaceType DimExprs Dimsopt
  3744. \:$MakeArrayCreationExpression:\
  3745. /.$shared_function
  3746. //
  3747. // void MakeArrayCreationExpression(void);
  3748. //./
  3749.  
  3750. --1.1 feature
  3751. ArrayCreationExpression ::= 'new' ArrayType ArrayInitializer
  3752. \:$action:\
  3753. /.$location
  3754. void Parser::Act$rule_number(void)
  3755. {
  3756.     AstArrayCreationExpression *p = ast_pool -> NewArrayCreationExpression();
  3757.     p -> new_token             = Token(1);
  3758.     p -> array_type            = Sym(2);
  3759.     p -> array_initializer_opt = (AstArrayInitializer *) Sym(3);
  3760.     Sym(1) = p;
  3761. }
  3762. ./
  3763.  
  3764. DimExprs ::= DimExpr
  3765. \:$action:\
  3766. /.$location
  3767. //
  3768. // Note that the list is circular so as to preserve the order of the elements
  3769. //
  3770. void Parser::Act$rule_number(void)
  3771. {
  3772.     AstListNode *p = AllocateListNode();
  3773.     p -> next = p;
  3774.     p -> element = Sym(1);
  3775.     p -> index = 0;
  3776.  
  3777.     Sym(1) = p;
  3778. }
  3779. ./
  3780.  
  3781. DimExprs ::= DimExprs DimExpr
  3782. \:$action:\
  3783. /.$location
  3784. //
  3785. // Note that the list is circular so as to preserve the order of the elements
  3786. //
  3787. void Parser::Act$rule_number(void)
  3788. {
  3789.     AstListNode *tail = (AstListNode *) Sym(1);
  3790.  
  3791.     AstListNode *p = AllocateListNode();
  3792.     p -> element = Sym(2);
  3793.     p -> index = tail -> index + 1;
  3794.  
  3795.     p -> next = tail -> next;
  3796.     tail -> next = p;
  3797.  
  3798.     Sym(1) = p;
  3799. }
  3800. ./
  3801.  
  3802. DimExpr ::= '[' Expression ']'
  3803. \:$action:\
  3804. /.$location
  3805. void Parser::Act$rule_number(void)
  3806. {
  3807.     AstDimExpr *p = ast_pool -> NewDimExpr();
  3808.     p -> left_bracket_token  = Token(1);
  3809.     p -> expression          = (AstExpression *) Sym(2);
  3810.     p -> right_bracket_token = Token(3);
  3811.     Sym(1) = p;
  3812. }
  3813. ./
  3814.  
  3815. Dims ::= '[' ']'
  3816. \:$action:\
  3817. /.$location
  3818. //
  3819. // Note that the list is circular so as to preserve the order of the elements
  3820. //
  3821. void Parser::Act$rule_number(void)
  3822. {
  3823.     AstListNode *p = AllocateListNode();
  3824.     p -> next = p;
  3825.     p -> element = ast_pool -> NewBrackets(Token(1), Token(2));
  3826.     p -> index = 0;
  3827.  
  3828.     Sym(1) = p;
  3829. }
  3830. ./
  3831.  
  3832. Dims ::= Dims '[' ']'
  3833. \:$action:\
  3834. /.$location
  3835. //
  3836. // Note that the list is circular so as to preserve the order of the elements
  3837. //
  3838. void Parser::Act$rule_number(void)
  3839. {
  3840.     AstListNode *tail = (AstListNode *) Sym(1);
  3841.  
  3842.     AstListNode *p = AllocateListNode();
  3843.     p -> element = ast_pool -> NewBrackets(Token(2), Token(3));
  3844.     p -> index = tail -> index + 1;
  3845.  
  3846.     p -> next = tail -> next;
  3847.     tail -> next = p;
  3848.  
  3849.     Sym(1) = p;
  3850. }
  3851. ./
  3852.  
  3853. FieldAccess ::= Primary '.' 'Identifier'
  3854. \:$MakeFieldAccess:\
  3855. /.$shared_function
  3856. //
  3857. // void MakeFieldAccess(void);
  3858. //./
  3859.  
  3860. FieldAccess ::= 'super' '.' 'Identifier'
  3861. \:$MakeSuperFieldAccess:\
  3862. /.$location
  3863. void Parser::MakeSuperFieldAccess(void)
  3864. {
  3865.     Sym(1) = ast_pool -> NewSuperExpression(Token(1));
  3866.  
  3867.     MakeFieldAccess();
  3868. }
  3869. ./
  3870.  
  3871. --1.2 feature
  3872. FieldAccess ::= Name '.' 'super' '.' 'Identifier'
  3873. \:$MakeSuperDoubleFieldAccess:\
  3874. /.$location
  3875. void Parser::MakeSuperDoubleFieldAccess(void)
  3876. {
  3877.     AstFieldAccess *p = ast_pool -> NewFieldAccess();
  3878.  
  3879.          AstFieldAccess *q = ast_pool -> NewFieldAccess(AstFieldAccess::SUPER_TAG);
  3880.          q -> base = (AstExpression *) Sym(1);
  3881.          q -> dot_token = Token(2);
  3882.          q -> identifier_token = Token(3);
  3883.  
  3884.     p -> base = q;
  3885.     p -> dot_token = Token(4);
  3886.     p -> identifier_token = Token(5);
  3887.  
  3888.     Sym(1) = p;
  3889. }
  3890. ./
  3891.  
  3892. MethodInvocation ::= Name '(' ArgumentListopt ')'
  3893. \:$action:\
  3894. /.$location
  3895. void Parser::Act$rule_number(void)
  3896. {
  3897.     AstMethodInvocation *p = ast_pool -> NewMethodInvocation();
  3898.     p -> method                  = (AstExpression *) Sym(1);
  3899.     p -> left_parenthesis_token  = Token(2);
  3900.     if (Sym(3) != NULL)
  3901.     {
  3902.         AstListNode *tail = (AstListNode *) Sym(3);
  3903.         p -> AllocateArguments(tail -> index + 1);
  3904.         AstListNode *root = tail;
  3905.         do
  3906.         {
  3907.             root = root -> next;
  3908.             p -> AddArgument((AstExpression *) root -> element);
  3909.         } while(root != tail);
  3910.         FreeCircularList(tail);
  3911.     }
  3912.     p -> right_parenthesis_token = Token(4);
  3913.     Sym(1) = p;
  3914. }
  3915. ./
  3916.  
  3917. MethodInvocation ::= Primary '.' 'Identifier' '(' ArgumentListopt ')'
  3918. \:$action:\
  3919. /.$location
  3920. void Parser::Act$rule_number(void)
  3921. {
  3922.     MakeFieldAccess();
  3923.  
  3924.     AstMethodInvocation *p = ast_pool -> NewMethodInvocation();
  3925.     p -> method                  = (AstExpression *) Sym(1);
  3926.     p -> left_parenthesis_token  = Token(4);
  3927.     if (Sym(5) != NULL)
  3928.     {
  3929.         AstListNode *tail = (AstListNode *) Sym(5);
  3930.         p -> AllocateArguments(tail -> index + 1);
  3931.         AstListNode *root = tail;
  3932.         do
  3933.         {
  3934.             root = root -> next;
  3935.             p -> AddArgument((AstExpression *) root -> element);
  3936.         } while(root != tail);
  3937.         FreeCircularList(tail);
  3938.     }
  3939.     p -> right_parenthesis_token = Token(6);
  3940.     Sym(1) = p;
  3941. }
  3942. ./
  3943.  
  3944. MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')'
  3945. \:$action:\
  3946. /.$location
  3947. void Parser::Act$rule_number(void)
  3948. {
  3949.     MakeSuperFieldAccess();
  3950.  
  3951.     AstMethodInvocation *p = ast_pool -> NewMethodInvocation();
  3952.     p -> method                  = (AstExpression *) Sym(1);
  3953.     p -> left_parenthesis_token  = Token(4);
  3954.     if (Sym(5) != NULL)
  3955.     {
  3956.         AstListNode *tail = (AstListNode *) Sym(5);
  3957.         p -> AllocateArguments(tail -> index + 1);
  3958.         AstListNode *root = tail;
  3959.         do
  3960.         {
  3961.             root = root -> next;
  3962.             p -> AddArgument((AstExpression *) root -> element);
  3963.         } while(root != tail);
  3964.         FreeCircularList(tail);
  3965.     }
  3966.     p -> right_parenthesis_token = Token(6);
  3967.     Sym(1) = p;
  3968. }
  3969. ./
  3970.  
  3971. --1.2 feature
  3972. MethodInvocation ::= Name '.' 'super' '.' 'Identifier' '(' ArgumentListopt ')'
  3973. \:$action:\
  3974. /.$location
  3975. void Parser::Act$rule_number(void)
  3976. {
  3977.     MakeSuperDoubleFieldAccess();
  3978.  
  3979.     AstMethodInvocation *p = ast_pool -> NewMethodInvocation();
  3980.     p -> method                  = (AstExpression *) Sym(1);
  3981.     p -> left_parenthesis_token  = Token(6);
  3982.     if (Sym(7) != NULL)
  3983.     {
  3984.         AstListNode *tail = (AstListNode *) Sym(7);
  3985.         p -> AllocateArguments(tail -> index + 1);
  3986.         AstListNode *root = tail;
  3987.         do
  3988.         {
  3989.             root = root -> next;
  3990.             p -> AddArgument((AstExpression *) root -> element);
  3991.         } while(root != tail);
  3992.         FreeCircularList(tail);
  3993.     }
  3994.     p -> right_parenthesis_token = Token(8);
  3995.     Sym(1) = p;
  3996. }
  3997. ./
  3998.  
  3999. ArrayAccess ::= Name '[' Expression ']'
  4000. \:$MakeArrayAccess:\
  4001. /.$location
  4002. void Parser::MakeArrayAccess(void)
  4003. {
  4004.     AstArrayAccess *p = ast_pool -> NewArrayAccess();
  4005.     p -> base                = (AstExpression *) Sym(1);
  4006.     p -> left_bracket_token  = Token(2);
  4007.     p -> expression          = (AstExpression *) Sym(3);
  4008.     p -> right_bracket_token = Token(4);
  4009.     Sym(1) = p;
  4010. }
  4011. ./
  4012.  
  4013. ArrayAccess ::= PrimaryNoNewArray '[' Expression ']'
  4014. \:$MakeArrayAccess:\
  4015. /.$shared_function
  4016. //
  4017. // void MakeArrayAccess(void);
  4018. //./
  4019.  
  4020. PostfixExpression -> Primary
  4021. \:$NoAction:\
  4022. /.$shared_NoAction./
  4023.  
  4024. PostfixExpression -> Name
  4025. \:$NoAction:\
  4026. /.$shared_NoAction./
  4027.  
  4028. PostfixExpression -> PostIncrementExpression
  4029. \:$NoAction:\
  4030. /.$shared_NoAction./
  4031.  
  4032. PostfixExpression -> PostDecrementExpression
  4033. \:$NoAction:\
  4034. /.$shared_NoAction./
  4035.  
  4036. PostIncrementExpression ::= PostfixExpression '++'
  4037. \:$action:\
  4038. /.$location
  4039. void Parser::Act$rule_number(void)
  4040. {
  4041.     AstPostUnaryExpression *p = ast_pool -> NewPostUnaryExpression(AstPostUnaryExpression::PLUSPLUS);
  4042.     p -> expression          = (AstExpression *) Sym(1);
  4043.     p -> post_operator_token = Token(2);
  4044.     Sym(1) = p;
  4045. }
  4046. ./
  4047.  
  4048. PostDecrementExpression ::= PostfixExpression '--'
  4049. \:$action:\
  4050. /.$location
  4051. void Parser::Act$rule_number(void)
  4052. {
  4053.     AstPostUnaryExpression *p = ast_pool -> NewPostUnaryExpression(AstPostUnaryExpression::MINUSMINUS);
  4054.     p -> expression          = (AstExpression *) Sym(1);
  4055.     p -> post_operator_token = Token(2);
  4056.     Sym(1) = p;
  4057. }
  4058. ./
  4059.  
  4060. UnaryExpression -> PreIncrementExpression
  4061. \:$NoAction:\
  4062. /.$shared_NoAction./
  4063.  
  4064. UnaryExpression -> PreDecrementExpression
  4065. \:$NoAction:\
  4066. /.$shared_NoAction./
  4067.  
  4068. UnaryExpression ::= '+' UnaryExpression
  4069. \:$action:\
  4070. /.$location
  4071. void Parser::Act$rule_number(void)
  4072. {
  4073.     AstPreUnaryExpression *p = ast_pool -> NewPreUnaryExpression(AstPreUnaryExpression::PLUS);
  4074.     p -> pre_operator_token = Token(1);
  4075.     p -> expression         = (AstExpression *) Sym(2);
  4076.     Sym(1) = p;
  4077. }
  4078. ./
  4079.  
  4080. UnaryExpression ::= '-' UnaryExpression
  4081. \:$action:\
  4082. /.$location
  4083. void Parser::Act$rule_number(void)
  4084. {
  4085.     AstPreUnaryExpression *p = ast_pool -> NewPreUnaryExpression(AstPreUnaryExpression::MINUS);
  4086.     p -> pre_operator_token = Token(1);
  4087.     p -> expression         = (AstExpression *) Sym(2);
  4088.     Sym(1) = p;
  4089. }
  4090. ./
  4091.  
  4092. UnaryExpression -> UnaryExpressionNotPlusMinus
  4093. \:$NoAction:\
  4094. /.$shared_NoAction./
  4095.  
  4096. PreIncrementExpression ::= '++' UnaryExpression
  4097. \:$action:\
  4098. /.$location
  4099. void Parser::Act$rule_number(void)
  4100. {
  4101.     AstPreUnaryExpression *p = ast_pool -> NewPreUnaryExpression(AstPreUnaryExpression::PLUSPLUS);
  4102.     p -> pre_operator_token = Token(1);
  4103.     p -> expression         = (AstExpression *) Sym(2);
  4104.     Sym(1) = p;
  4105. }
  4106. ./
  4107.  
  4108. PreDecrementExpression ::= '--' UnaryExpression
  4109. \:$action:\
  4110. /.$location
  4111. void Parser::Act$rule_number(void)
  4112. {
  4113.     AstPreUnaryExpression *p = ast_pool -> NewPreUnaryExpression(AstPreUnaryExpression::MINUSMINUS);
  4114.     p -> pre_operator_token = Token(1);
  4115.     p -> expression         = (AstExpression *) Sym(2);
  4116.     Sym(1) = p;
  4117. }
  4118. ./
  4119.  
  4120. UnaryExpressionNotPlusMinus -> PostfixExpression
  4121. \:$NoAction:\
  4122. /.$shared_NoAction./
  4123.  
  4124. UnaryExpressionNotPlusMinus ::= '~' UnaryExpression
  4125. \:$action:\
  4126. /.$location
  4127. void Parser::Act$rule_number(void)
  4128. {
  4129.     AstPreUnaryExpression *p = ast_pool -> NewPreUnaryExpression(AstPreUnaryExpression::TWIDDLE);
  4130.     p -> pre_operator_token = Token(1);
  4131.     p -> expression         = (AstExpression *) Sym(2);
  4132.     Sym(1) = p;
  4133. }
  4134. ./
  4135.  
  4136. UnaryExpressionNotPlusMinus ::= '!' UnaryExpression
  4137. \:$action:\
  4138. /.$location
  4139. void Parser::Act$rule_number(void)
  4140. {
  4141.     AstPreUnaryExpression *p = ast_pool -> NewPreUnaryExpression(AstPreUnaryExpression::NOT);
  4142.     p -> pre_operator_token = Token(1);
  4143.     p -> expression         = (AstExpression *) Sym(2);
  4144.     Sym(1) = p;
  4145. }
  4146. ./
  4147.  
  4148. UnaryExpressionNotPlusMinus -> CastExpression
  4149. \:$NoAction:\
  4150. /.$shared_NoAction./
  4151.  
  4152. CastExpression ::= '(' PrimitiveType Dimsopt ')' UnaryExpression
  4153. \:$MakeCastExpression:\
  4154. /.$location
  4155. void Parser::MakeCastExpression(void)
  4156. {
  4157.     AstCastExpression *p = ast_pool -> NewCastExpression();
  4158.     p -> left_parenthesis_token_opt  = Token(1);
  4159.     p -> type_opt                    = Sym(2);
  4160.     if (Sym(3) != NULL)
  4161.     {
  4162.         AstListNode *tail = (AstListNode *) Sym(3);
  4163.         p -> AllocateBrackets(tail -> index + 1);
  4164.         AstListNode *root = tail;
  4165.         do
  4166.         {
  4167.             root = root -> next;
  4168.             p -> AddBrackets((AstBrackets *) root -> element);
  4169.         } while(root != tail);
  4170.         FreeCircularList(tail);
  4171.     }
  4172.     p -> right_parenthesis_token_opt = Token(4);
  4173.     p -> expression                  = (AstExpression *) Sym(5);
  4174.     Sym(1) = p;
  4175. }
  4176. ./
  4177.  
  4178. CastExpression ::= '(' Expression ')' UnaryExpressionNotPlusMinus
  4179. \:$action:\
  4180. /.$location
  4181. void Parser::Act$rule_number(void)
  4182. { 
  4183.     //
  4184.     // Note that Expression must be a name - i.e., Sym(2) -> isName() == true
  4185.     // This check is not performed here and should be performed during
  4186.     // semantic processing.
  4187.     //
  4188.     AstCastExpression *p = ast_pool -> NewCastExpression();
  4189.     p -> left_parenthesis_token_opt  = Token(1);
  4190.     p -> type_opt                    = Sym(2);
  4191.     p -> right_parenthesis_token_opt = Token(3);
  4192.     p -> expression                  = (AstExpression *) Sym(4);
  4193.     Sym(1) = p;
  4194. }
  4195. ./
  4196.  
  4197. CastExpression ::= '(' Name Dims ')' UnaryExpressionNotPlusMinus
  4198. \:$MakeCastExpression:\
  4199. /.$shared_function
  4200. //
  4201. // void MakeCastExpression(void);
  4202. //./
  4203.  
  4204. MultiplicativeExpression -> UnaryExpression
  4205. \:$NoAction:\
  4206. /.$shared_NoAction./
  4207.  
  4208. MultiplicativeExpression ::= MultiplicativeExpression '*' UnaryExpression
  4209. \:$action:\
  4210. /.$location
  4211. void Parser::Act$rule_number(void)
  4212. {
  4213.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::STAR);
  4214.     p -> left_expression       = (AstExpression *) Sym(1);
  4215.     p -> binary_operator_token = Token(2);
  4216.     p -> right_expression      = (AstExpression *) Sym(3);
  4217.     Sym(1) = p;
  4218. }
  4219. ./
  4220.  
  4221. MultiplicativeExpression ::= MultiplicativeExpression '/' UnaryExpression
  4222. \:$action:\
  4223. /.$location
  4224. void Parser::Act$rule_number(void)
  4225. {
  4226.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::SLASH);
  4227.     p -> left_expression       = (AstExpression *) Sym(1);
  4228.     p -> binary_operator_token = Token(2);
  4229.     p -> right_expression      = (AstExpression *) Sym(3);
  4230.     Sym(1) = p;
  4231. }
  4232. ./
  4233.  
  4234. MultiplicativeExpression ::= MultiplicativeExpression '%' UnaryExpression
  4235. \:$action:\
  4236. /.$location
  4237. void Parser::Act$rule_number(void)
  4238. {
  4239.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::MOD);
  4240.     p -> left_expression       = (AstExpression *) Sym(1);
  4241.     p -> binary_operator_token = Token(2);
  4242.     p -> right_expression      = (AstExpression *) Sym(3);
  4243.     Sym(1) = p;
  4244. }
  4245. ./
  4246.  
  4247. AdditiveExpression -> MultiplicativeExpression
  4248. \:$NoAction:\
  4249. /.$shared_NoAction./
  4250.  
  4251. AdditiveExpression ::= AdditiveExpression '+' MultiplicativeExpression
  4252. \:$action:\
  4253. /.$location
  4254. void Parser::Act$rule_number(void)
  4255. {
  4256.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::PLUS);
  4257.     p -> left_expression       = (AstExpression *) Sym(1);
  4258.     p -> binary_operator_token = Token(2);
  4259.     p -> right_expression      = (AstExpression *) Sym(3);
  4260.     Sym(1) = p;
  4261. }
  4262. ./
  4263.  
  4264. AdditiveExpression ::= AdditiveExpression '-' MultiplicativeExpression
  4265. \:$action:\
  4266. /.$location
  4267. void Parser::Act$rule_number(void)
  4268. {
  4269.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::MINUS);
  4270.     p -> left_expression       = (AstExpression *) Sym(1);
  4271.     p -> binary_operator_token = Token(2);
  4272.     p -> right_expression      = (AstExpression *) Sym(3);
  4273.     Sym(1) = p;
  4274. }
  4275. ./
  4276.  
  4277. ShiftExpression -> AdditiveExpression
  4278. \:$NoAction:\
  4279. /.$shared_NoAction./
  4280.  
  4281. ShiftExpression ::= ShiftExpression '<<'  AdditiveExpression
  4282. \:$action:\
  4283. /.$location
  4284. void Parser::Act$rule_number(void)
  4285. {
  4286.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::LEFT_SHIFT);
  4287.     p -> left_expression       = (AstExpression *) Sym(1);
  4288.     p -> binary_operator_token = Token(2);
  4289.     p -> right_expression      = (AstExpression *) Sym(3);
  4290.     Sym(1) = p;
  4291. }
  4292. ./
  4293.  
  4294. ShiftExpression ::= ShiftExpression '>>'  AdditiveExpression
  4295. \:$action:\
  4296. /.$location
  4297. void Parser::Act$rule_number(void)
  4298. {
  4299.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::RIGHT_SHIFT);
  4300.     p -> left_expression       = (AstExpression *) Sym(1);
  4301.     p -> binary_operator_token = Token(2);
  4302.     p -> right_expression      = (AstExpression *) Sym(3);
  4303.     Sym(1) = p;
  4304. }
  4305. ./
  4306.  
  4307. ShiftExpression ::= ShiftExpression '>>>' AdditiveExpression
  4308. \:$action:\
  4309. /.$location
  4310. void Parser::Act$rule_number(void)
  4311. {
  4312.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::UNSIGNED_RIGHT_SHIFT);
  4313.     p -> left_expression       = (AstExpression *) Sym(1);
  4314.     p -> binary_operator_token = Token(2);
  4315.     p -> right_expression      = (AstExpression *) Sym(3);
  4316.     Sym(1) = p;
  4317. }
  4318. ./
  4319.  
  4320. RelationalExpression -> ShiftExpression
  4321. \:$NoAction:\
  4322. /.$shared_NoAction./
  4323.  
  4324. RelationalExpression ::= RelationalExpression '<'  ShiftExpression
  4325. \:$action:\
  4326. /.$location
  4327. void Parser::Act$rule_number(void)
  4328. {
  4329.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::LESS);
  4330.     p -> left_expression       = (AstExpression *) Sym(1);
  4331.     p -> binary_operator_token = Token(2);
  4332.     p -> right_expression      = (AstExpression *) Sym(3);
  4333.     Sym(1) = p;
  4334. }
  4335. ./
  4336.  
  4337. RelationalExpression ::= RelationalExpression '>'  ShiftExpression
  4338. \:$action:\
  4339. /.$location
  4340. void Parser::Act$rule_number(void)
  4341. {
  4342.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::GREATER);
  4343.     p -> left_expression       = (AstExpression *) Sym(1);
  4344.     p -> binary_operator_token = Token(2);
  4345.     p -> right_expression      = (AstExpression *) Sym(3);
  4346.     Sym(1) = p;
  4347. }
  4348. ./
  4349.  
  4350. RelationalExpression ::= RelationalExpression '<=' ShiftExpression
  4351. \:$action:\
  4352. /.$location
  4353. void Parser::Act$rule_number(void)
  4354. {
  4355.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::LESS_EQUAL);
  4356.     p -> left_expression       = (AstExpression *) Sym(1);
  4357.     p -> binary_operator_token = Token(2);
  4358.     p -> right_expression      = (AstExpression *) Sym(3);
  4359.     Sym(1) = p;
  4360. }
  4361. ./
  4362.  
  4363. RelationalExpression ::= RelationalExpression '>=' ShiftExpression
  4364. \:$action:\
  4365. /.$location
  4366. void Parser::Act$rule_number(void)
  4367. {
  4368.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::GREATER_EQUAL);
  4369.     p -> left_expression       = (AstExpression *) Sym(1);
  4370.     p -> binary_operator_token = Token(2);
  4371.     p -> right_expression      = (AstExpression *) Sym(3);
  4372.     Sym(1) = p;
  4373. }
  4374. ./
  4375.  
  4376. RelationalExpression ::= RelationalExpression 'instanceof' ReferenceType
  4377. \:$action:\
  4378. /.$location
  4379. void Parser::Act$rule_number(void)
  4380. {
  4381.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::INSTANCEOF);
  4382.     p -> left_expression       = (AstExpression *) Sym(1);
  4383.     p -> binary_operator_token = Token(2);
  4384.     p -> right_expression      = ast_pool -> NewTypeExpression(Sym(3));
  4385.     Sym(1) = p;
  4386. }
  4387. ./
  4388.  
  4389. EqualityExpression -> RelationalExpression
  4390. \:$NoAction:\
  4391. /.$shared_NoAction./
  4392.  
  4393. EqualityExpression ::= EqualityExpression '==' RelationalExpression
  4394. \:$action:\
  4395. /.$location
  4396. void Parser::Act$rule_number(void)
  4397. {
  4398.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::EQUAL_EQUAL);
  4399.     p -> left_expression       = (AstExpression *) Sym(1);
  4400.     p -> binary_operator_token = Token(2);
  4401.     p -> right_expression      = (AstExpression *) Sym(3);
  4402.     Sym(1) = p;
  4403. }
  4404. ./
  4405.  
  4406. EqualityExpression ::= EqualityExpression '!=' RelationalExpression
  4407. \:$action:\
  4408. /.$location
  4409. void Parser::Act$rule_number(void)
  4410. {
  4411.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::NOT_EQUAL);
  4412.     p -> left_expression       = (AstExpression *) Sym(1);
  4413.     p -> binary_operator_token = Token(2);
  4414.     p -> right_expression      = (AstExpression *) Sym(3);
  4415.     Sym(1) = p;
  4416. }
  4417. ./
  4418.  
  4419.  
  4420. AndExpression -> EqualityExpression
  4421. \:$NoAction:\
  4422. /.$shared_NoAction./
  4423.  
  4424. AndExpression ::= AndExpression '&' EqualityExpression
  4425. \:$action:\
  4426. /.$location
  4427. void Parser::Act$rule_number(void)
  4428. {
  4429.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::AND);
  4430.     p -> left_expression       = (AstExpression *) Sym(1);
  4431.     p -> binary_operator_token = Token(2);
  4432.     p -> right_expression      = (AstExpression *) Sym(3);
  4433.     Sym(1) = p;
  4434. }
  4435. ./
  4436.  
  4437. ExclusiveOrExpression -> AndExpression
  4438. \:$NoAction:\
  4439. /.$shared_NoAction./
  4440.  
  4441. ExclusiveOrExpression ::= ExclusiveOrExpression '^' AndExpression
  4442. \:$action:\
  4443. /.$location
  4444. void Parser::Act$rule_number(void)
  4445. {
  4446.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::XOR);
  4447.     p -> left_expression       = (AstExpression *) Sym(1);
  4448.     p -> binary_operator_token = Token(2);
  4449.     p -> right_expression      = (AstExpression *) Sym(3);
  4450.     Sym(1) = p;
  4451. }
  4452. ./
  4453.  
  4454. InclusiveOrExpression -> ExclusiveOrExpression
  4455. \:$NoAction:\
  4456. /.$shared_NoAction./
  4457.  
  4458. InclusiveOrExpression ::= InclusiveOrExpression '|' ExclusiveOrExpression
  4459. \:$action:\
  4460. /.$location
  4461. void Parser::Act$rule_number(void)
  4462. {
  4463.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::IOR);
  4464.     p -> left_expression       = (AstExpression *) Sym(1);
  4465.     p -> binary_operator_token = Token(2);
  4466.     p -> right_expression      = (AstExpression *) Sym(3);
  4467.     Sym(1) = p;
  4468. }
  4469. ./
  4470.  
  4471. ConditionalAndExpression -> InclusiveOrExpression
  4472. \:$NoAction:\
  4473. /.$shared_NoAction./
  4474.  
  4475. ConditionalAndExpression ::= ConditionalAndExpression '&&' InclusiveOrExpression
  4476. \:$action:\
  4477. /.$location
  4478. void Parser::Act$rule_number(void)
  4479. {
  4480.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::AND_AND);
  4481.     p -> left_expression       = (AstExpression *) Sym(1);
  4482.     p -> binary_operator_token = Token(2);
  4483.     p -> right_expression      = (AstExpression *) Sym(3);
  4484.     Sym(1) = p;
  4485. }
  4486. ./
  4487.  
  4488. ConditionalOrExpression -> ConditionalAndExpression
  4489. \:$NoAction:\
  4490. /.$shared_NoAction./
  4491.  
  4492. ConditionalOrExpression ::= ConditionalOrExpression '||' ConditionalAndExpression
  4493. \:$action:\
  4494. /.$location
  4495. void Parser::Act$rule_number(void)
  4496. {
  4497.     AstBinaryExpression *p = ast_pool -> NewBinaryExpression(AstBinaryExpression::OR_OR);
  4498.     p -> left_expression       = (AstExpression *) Sym(1);
  4499.     p -> binary_operator_token = Token(2);
  4500.     p -> right_expression      = (AstExpression *) Sym(3);
  4501.     Sym(1) = p;
  4502. }
  4503. ./
  4504.  
  4505. ConditionalExpression -> ConditionalOrExpression
  4506. \:$NoAction:\
  4507. /.$shared_NoAction./
  4508.  
  4509. ConditionalExpression ::= ConditionalOrExpression '?' Expression ':' ConditionalExpression
  4510. \:$action:\
  4511. /.$location
  4512. void Parser::Act$rule_number(void)
  4513. {
  4514.     AstConditionalExpression *p = ast_pool -> NewConditionalExpression();
  4515.     p -> test_expression  = (AstExpression *) Sym(1);
  4516.     p -> question_token   = Token(2);
  4517.     p -> true_expression  = (AstExpression *) Sym(3);
  4518.     p -> colon_token      = Token(4);
  4519.     p -> false_expression = (AstExpression *) Sym(5);
  4520.     Sym(1) = p;
  4521. }
  4522. ./
  4523.  
  4524. AssignmentExpression -> ConditionalExpression
  4525. \:$NoAction:\
  4526. /.$shared_NoAction./
  4527.  
  4528. AssignmentExpression -> Assignment
  4529. \:$NoAction:\
  4530. /.$shared_NoAction./
  4531.  
  4532. Assignment ::= LeftHandSide AssignmentOperator AssignmentExpression
  4533. \:$action:\
  4534. /.$location
  4535. void Parser::Act$rule_number(void)
  4536. {
  4537.     AstAssignmentExpression *p = (AstAssignmentExpression *) Sym(2);
  4538.     p -> left_hand_side = (AstExpression *) Sym(1);
  4539.     p -> expression     = (AstExpression *) Sym(3);
  4540.     Sym(1) = p;
  4541. }
  4542. ./
  4543.  
  4544. LeftHandSide -> Name
  4545. \:$NoAction:\
  4546. /.$shared_NoAction./
  4547.  
  4548. LeftHandSide -> FieldAccess
  4549. \:$NoAction:\
  4550. /.$shared_NoAction./
  4551.  
  4552. LeftHandSide -> ArrayAccess
  4553. \:$NoAction:\
  4554. /.$shared_NoAction./
  4555.  
  4556. AssignmentOperator ::= '='
  4557. \:$action:\
  4558. /.$location
  4559. void Parser::Act$rule_number(void)
  4560. {
  4561.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::EQUAL, Token(1));
  4562. }
  4563. ./
  4564.  
  4565. AssignmentOperator ::= '*='
  4566. \:$action:\
  4567. /.$location
  4568. void Parser::Act$rule_number(void)
  4569. {
  4570.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::STAR_EQUAL, Token(1));
  4571. }
  4572. ./
  4573.  
  4574. AssignmentOperator ::= '/='
  4575. \:$action:\
  4576. /.$location
  4577. void Parser::Act$rule_number(void)
  4578. {
  4579.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::SLASH_EQUAL, Token(1));
  4580. }
  4581. ./
  4582.  
  4583. AssignmentOperator ::= '%='
  4584. \:$action:\
  4585. /.$location
  4586. void Parser::Act$rule_number(void)
  4587. {
  4588.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::MOD_EQUAL, Token(1));
  4589. }
  4590. ./
  4591.  
  4592. AssignmentOperator ::= '+='
  4593. \:$action:\
  4594. /.$location
  4595. void Parser::Act$rule_number(void)
  4596. {
  4597.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::PLUS_EQUAL, Token(1));
  4598. }
  4599. ./
  4600.  
  4601. AssignmentOperator ::= '-='
  4602. \:$action:\
  4603. /.$location
  4604. void Parser::Act$rule_number(void)
  4605. {
  4606.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::MINUS_EQUAL, Token(1));
  4607. }
  4608. ./
  4609.  
  4610. AssignmentOperator ::= '<<='
  4611. \:$action:\
  4612. /.$location
  4613. void Parser::Act$rule_number(void)
  4614. {
  4615.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::LEFT_SHIFT_EQUAL, Token(1));
  4616. }
  4617. ./
  4618.  
  4619. AssignmentOperator ::= '>>='
  4620. \:$action:\
  4621. /.$location
  4622. void Parser::Act$rule_number(void)
  4623. {
  4624.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::RIGHT_SHIFT_EQUAL, Token(1));
  4625. }
  4626. ./
  4627.  
  4628. AssignmentOperator ::= '>>>='
  4629. \:$action:\
  4630. /.$location
  4631. void Parser::Act$rule_number(void)
  4632. {
  4633.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::UNSIGNED_RIGHT_SHIFT_EQUAL, Token(1));
  4634. }
  4635. ./
  4636.  
  4637. AssignmentOperator ::= '&='
  4638. \:$action:\
  4639. /.$location
  4640. void Parser::Act$rule_number(void)
  4641. {
  4642.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::AND_EQUAL, Token(1));
  4643. }
  4644. ./
  4645.  
  4646. AssignmentOperator ::= '^='
  4647. \:$action:\
  4648. /.$location
  4649. void Parser::Act$rule_number(void)
  4650. {
  4651.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::XOR_EQUAL, Token(1));
  4652. }
  4653. ./
  4654.  
  4655. AssignmentOperator ::= '|='
  4656. \:$action:\
  4657. /.$location
  4658. void Parser::Act$rule_number(void)
  4659. {
  4660.     Sym(1) = ast_pool -> NewAssignmentExpression(AstAssignmentExpression::IOR_EQUAL, Token(1));
  4661. }
  4662. ./
  4663.  
  4664. Expression -> AssignmentExpression
  4665. \:$NoAction:\
  4666. /.$shared_NoAction./
  4667.  
  4668. ConstantExpression -> Expression
  4669. \:$NoAction:\
  4670. /.$shared_NoAction./
  4671.  
  4672. ---------------------------------------------------------------------------------------
  4673. --
  4674. -- The following rules are for optional nonterminals.
  4675. --
  4676. ---------------------------------------------------------------------------------------
  4677.  
  4678. PackageDeclarationopt ::= $empty
  4679. \:$NullAction:\
  4680. /.$location
  4681. //
  4682. // Given a rule of the form A ::= x1 x2 ... xn
  4683. //
  4684. // Construct a NULL Ast for A.
  4685. //
  4686. void Parser::NullAction(void) { Sym(1) = NULL; }
  4687. ./
  4688.  
  4689. PackageDeclarationopt -> PackageDeclaration
  4690. \:$NoAction:\
  4691. /.$shared_NoAction./
  4692.  
  4693. Superopt ::= $empty
  4694. \:$NullAction:\
  4695. /.$shared_NullAction./
  4696.  
  4697. Superopt -> Super
  4698. \:$NoAction:\
  4699. /.$shared_NoAction./
  4700.  
  4701. Expressionopt ::= $empty
  4702. \:$NullAction:\
  4703. /.$shared_NullAction./
  4704.  
  4705. Expressionopt -> Expression
  4706. \:$NoAction:\
  4707. /.$shared_NoAction./
  4708.  
  4709. --1.1 feature
  4710. ClassBodyopt ::= $empty
  4711. \:$NullAction:\
  4712. /.$shared_NullAction./
  4713.  
  4714. --1.1 feature
  4715. ClassBodyopt -> ClassBody
  4716. \:$NoAction:\
  4717. /.$shared_NoAction./
  4718.  
  4719. ---------------------------------------------------------------------------------------
  4720. --
  4721. -- The rules below are for optional terminal symbols.  An optional comma,
  4722. -- is only used in the context of an array initializer - It is a
  4723. -- "syntactic sugar" that otherwise serves no other purpose. By contrast,
  4724. -- an optional identifier is used in the definition of a break and 
  4725. -- continue statement. When the identifier does not appear, a NULL
  4726. -- is produced. When the identifier is present, the user should use the
  4727. -- corresponding Token(i) method. See break statement as an example.
  4728. --
  4729. ---------------------------------------------------------------------------------------
  4730.  
  4731. ,opt ::= $empty
  4732. \:$NullAction:\
  4733. /.$shared_NullAction./
  4734.  
  4735. ,opt -> ,
  4736. \:$NoAction:\
  4737. /.$shared_NoAction./
  4738.  
  4739. ImportDeclarationsopt ::= $empty
  4740. \:$NullAction:\
  4741. /.$shared_NullAction./
  4742.  
  4743. ImportDeclarationsopt -> ImportDeclarations
  4744. \:$NoAction:\
  4745. /.$shared_NoAction./
  4746.  
  4747. TypeDeclarationsopt ::= $empty
  4748. \:$NullAction:\
  4749. /.$shared_NullAction./
  4750.  
  4751. TypeDeclarationsopt -> TypeDeclarations
  4752. \:$NoAction:\
  4753. /.$shared_NoAction./
  4754.  
  4755. ClassBodyDeclarationsopt ::= $empty
  4756. \:$NullAction:\
  4757. /.$shared_NullAction./
  4758.  
  4759. ClassBodyDeclarationsopt -> ClassBodyDeclarations
  4760. \:$NoAction:\
  4761. /.$shared_NoAction./
  4762.  
  4763. Modifiersopt ::= $empty
  4764. \:$NullAction:\
  4765. /.$shared_NullAction./
  4766.  
  4767. Modifiersopt -> Modifiers
  4768. \:$NoAction:\
  4769. /.$shared_NoAction./
  4770.  
  4771. BlockStatementsopt ::= $empty
  4772. \:$NullAction:\
  4773. /.$shared_NullAction./
  4774.  
  4775. BlockStatementsopt -> BlockStatements
  4776. \:$NoAction:\
  4777. /.$shared_NoAction./
  4778.  
  4779. Dimsopt ::= $empty
  4780. \:$NullAction:\
  4781. /.$shared_NullAction./
  4782.  
  4783. Dimsopt -> Dims
  4784. \:$NoAction:\
  4785. /.$shared_NoAction./
  4786.  
  4787. ArgumentListopt ::= $empty
  4788. \:$NullAction:\
  4789. /.$shared_NullAction./
  4790.  
  4791. ArgumentListopt -> ArgumentList
  4792. \:$NoAction:\
  4793. /.$shared_NoAction./
  4794.  
  4795. Throwsopt ::= $empty
  4796. \:$NullAction:\
  4797. /.$shared_NullAction./
  4798.  
  4799. Throwsopt -> Throws
  4800. \:$NoAction:\
  4801. /.$shared_NoAction./
  4802.  
  4803. FormalParameterListopt ::= $empty
  4804. \:$NullAction:\
  4805. /.$shared_NullAction./
  4806.  
  4807. FormalParameterListopt -> FormalParameterList
  4808. \:$NoAction:\
  4809. /.$shared_NoAction./
  4810.  
  4811. Interfacesopt ::= $empty
  4812. \:$NullAction:\
  4813. /.$shared_NullAction./
  4814.  
  4815. Interfacesopt -> Interfaces
  4816. \:$NoAction:\
  4817. /.$shared_NoAction./
  4818.  
  4819. InterfaceMemberDeclarationsopt ::= $empty
  4820. \:$NullAction:\
  4821. /.$shared_NullAction./
  4822.  
  4823. InterfaceMemberDeclarationsopt -> InterfaceMemberDeclarations
  4824. \:$NoAction:\
  4825. /.$shared_NoAction./
  4826.  
  4827. ForInitopt ::= $empty
  4828. \:$NullAction:\
  4829. /.$shared_NullAction./
  4830.  
  4831. ForInitopt -> ForInit
  4832. \:$NoAction:\
  4833. /.$shared_NoAction./
  4834.  
  4835. ForUpdateopt ::= $empty
  4836. \:$NullAction:\
  4837. /.$shared_NullAction./
  4838.  
  4839. ForUpdateopt -> ForUpdate
  4840. \:$NoAction:\
  4841. /.$shared_NoAction./
  4842.  
  4843. ExtendsInterfacesopt ::= $empty
  4844. \:$NullAction:\
  4845. /.$shared_NullAction./
  4846.  
  4847. ExtendsInterfacesopt -> ExtendsInterfaces
  4848. \:$NoAction:\
  4849. /.$shared_NoAction./
  4850.  
  4851. Catchesopt ::= $empty
  4852. \:$NullAction:\
  4853. /.$shared_NullAction./
  4854.  
  4855. Catchesopt -> Catches
  4856. \:$NoAction:\
  4857. /.$shared_NoAction./
  4858.  
  4859. PackageHeaderMarker ::= $empty
  4860. \:$action:\
  4861. /.$location
  4862. //
  4863. // When this function is invoked, if the "parse_package_header_only" flag
  4864. // is turned on, we skip to the end-of-file token.
  4865. //
  4866. void Parser::Act$rule_number(void)
  4867. {
  4868.     if (parse_package_header_only)
  4869.         lex_stream -> Reset(lex_stream -> NumTokens() - 1); // point to the EOF token
  4870.     Sym(1) = NULL;
  4871. }
  4872. ./
  4873.  
  4874. MethodHeaderMarker ::= $empty
  4875. \:$action:\
  4876. /.$location
  4877. //
  4878. // When this function is invoked, if the "parse_header_only" flag
  4879. // is turned on, the body of the method being parsed is skipped.
  4880. //
  4881. void Parser::Act$rule_number(void)
  4882. {
  4883.     if (parse_header_only)
  4884.     {
  4885.         TokenObject token = Token(1);
  4886.  
  4887.         //
  4888.         // If the first token immediately following the method header
  4889.         // is not an open brace, then we have a syntactic error. Do
  4890.         // nothing and let the error recovery take care of it.
  4891.         //
  4892.         if (lex_stream -> Kind(token) == TK_LBRACE)
  4893.             lex_stream -> Reset(lex_stream -> MatchingBrace(token));
  4894.     }
  4895.  
  4896.     Sym(1) = NULL;
  4897. }
  4898. ./
  4899.  
  4900. ---------------------------------------------------------------------------------------
  4901.  
  4902. \:
  4903. #ifndef HEADERS
  4904.     return;
  4905. }
  4906. #endif
  4907. :\
  4908.  
  4909. $names
  4910.  
  4911. BodyMarker ::= '"class Identifier { ... MethodHeader "'
  4912.  
  4913. void ::= ResultType
  4914.  
  4915. PLUS_PLUS ::=    '++'   
  4916. MINUS_MINUS ::=    '--'   
  4917. EQUAL_EQUAL ::=    '=='   
  4918. LESS_EQUAL ::=    '<='   
  4919. GREATER_EQUAL ::=    '>='   
  4920. NOT_EQUAL ::=    '!='   
  4921. LEFT_SHIFT ::=    '<<'   
  4922. RIGHT_SHIFT ::=    '>>'   
  4923. UNSIGNED_RIGHT_SHIFT ::=    '>>>'  
  4924. PLUS_EQUAL ::=    '+='   
  4925. MINUS_EQUAL ::=    '-='   
  4926. MULTIPLY_EQUAL ::=    '*='   
  4927. DIVIDE_EQUAL ::=    '/='   
  4928. AND_EQUAL ::=    '&='   
  4929. OR_EQUAL ::=    '|='   
  4930. XOR_EQUAL ::=    '^='   
  4931. REMAINDER_EQUAL ::=    '%='   
  4932. LEFT_SHIFT_EQUAL ::=    '<<='  
  4933. RIGHT_SHIFT_EQUAL ::=    '>>='  
  4934. UNSIGNED_RIGHT_SHIFT_EQUAL ::=    '>>>=' 
  4935. OR_OR ::=    '||'   
  4936. AND_AND ::=    '&&'   
  4937.  
  4938. PLUS ::=    '+'    
  4939. MINUS ::=    '-'    
  4940. NOT ::=    '!'    
  4941. REMAINDER ::=    '%'    
  4942. XOR ::=    '^'    
  4943. AND ::=    '&'    
  4944. MULTIPLY ::=    '*'    
  4945. OR ::=    '|'    
  4946. TWIDDLE ::=    '~'    
  4947. DIVIDE ::=    '/'    
  4948. GREATER ::=    '>'    
  4949. LESS ::=    '<'    
  4950. LPAREN ::=    '('    
  4951. RPAREN ::=    ')'    
  4952. LBRACE ::=    '{'    
  4953. RBRACE ::=    '}'    
  4954. LBRACKET ::=    '['    
  4955. RBRACKET ::=    ']'    
  4956. SEMICOLON ::=    ';'    
  4957. QUESTION ::=    '?'    
  4958. COLON ::=    ':'    
  4959. COMMA ::=    ','    
  4960. DOT ::=    '.'    
  4961. EQUAL ::=    '='    
  4962.  
  4963. $end
  4964.